All Classes and Interfaces
Class
Description
Abstract class that modifies
AbstractSetTaskPropertyCmd to customize validation & logging for
Add Identity Link related Commands.Base class for implementing
AdminPlugins.Base class for implementing plugin REST resources for the admin application.
Base class for implementing an Admin Plugin root resource.
Abstract implementation of the
AppPlugin SPI.A abstract plugin resource class that may be used to implement
REST resources which are added to the REST application of the app.
A resource class that provides a plugins restful API.
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.
AbstractBpmnModelElementBuilder<B extends AbstractBpmnModelElementBuilder<B,E>,E extends BpmnModelElementInstance>
Abstract base class for implementing a
BpmnParseListener without being forced to implement
all methods provided, which makes the implementation more robust to future changes.AbstractCallableElementBuilder<B extends AbstractCallableElementBuilder<B,E>,E extends CallableElement>
Generic
ExecutionListener publishing events using the CDI event
infrastructure.Abstract base class for implementing a
CmmnTransformListener without being forced to implement
all methods provided, which make the implementation more robust to future changes.An implementation of
CockpitPlugin that comes with reasonable defaults.Base class for implementing a plugin REST resource.
A resource class that provides a cockpit plugins restful API.
Represents the abstract conditional event definition builder.
Deployer responsible to parse resource files and create the proper entities.Created by aakhmerov on 16.09.16.
AbstractEmbeddedSubProcessBuilder<B extends AbstractEmbeddedSubProcessBuilder<B,E>,E extends AbstractSubProcessBuilder>
Deprecated.
AbstractMultiInstanceLoopCharacteristicsBuilder<B extends AbstractMultiInstanceLoopCharacteristicsBuilder<B>>
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.
Deprecated.
Deprecated.
Adapter class for implementing process engine plugins
Abstract process engine resource that provides instantiations of all REST resources.
Abstract superclass for all query types.
Defines common query operations, such as sorting options and validation.
Base class to unify the getResource(boolean deserialized) and
getResourceBinary() methods for several subclasses.
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 implementing
TasklistPlugins.Base class for implementing plugin REST resources for the admin application.
Base class for implementing an Tasklist Plugin root resource.
A
Filter implementation that can be used to realize basic templating.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.
Abstract query class that adds methods to query for variable values.
Base class for implementing
WelcomePlugins.Base class for implementing plugin REST resources for the welcome application.
Base class for implementing a welcome Plugin root resource.
The BPMN element activationCondition of the BPMN tComplexGateway type
The BPMN element activationCondition of the BPMN tComplexGateway type
registers support for handling the annotations in the org.camunda.bpm.engine.annotations package.
simple place to stash the constants used throughout the code
responsible for providing <activiti:annotation-driven/> support.
the idea is that this bean post processor is responsible for registering all beans
that have the
org.camunda.bpm.engine.annotations.State annotation.an instance of a bean discovered to both have an
org.camunda.bpm.engine.ProcessEngineComponent.ActivitiComponent
and one or more org.camunda.bpm.engine.ProcessEngineComponent.ActivitiComponent annotations present.this class records and manages all known
org.camunda.bpm.engine.annotations.State - responding
beans in the JVM.The BPMN activity element
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.
The BPMN activity element
Delegate interface for the asyncAfter property update
Delegate interface for the asyncBefore property update.
An activity instance represents an instance of an activity.
An activity instance is the 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.
The admin application.
The rest api exposed by the admin application
SPI inteface for plugins to the admin webapplication.
The admin application service runtime delegate.
Servlet filter to ensure request paths always have a trailing slash.
This matcher can be used for restricting access to an app.
This class represents the data structure used for collecting information
about the application server.
The service provider interface (SPI) that must be provided by a webapplication plugin.
The holder of registered
AppPlugins.The list of services provided by a camunda webapplication, providing
a plugin registry and access to the process engine.
This is an empty service implementation illustrating how to use a plain
Java Class as a BPMN 2.0 Service Task delegate.
The BPMN artifact element
Create and destroy artifacts of a given class in a container specific way.
The BPMN artifact element
The BPMN assignment element
The BPMN assignment element
Can be used to qualify events fired when a task is assigned.
The BPMN association element
The BPMN tAssociationDirection type
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.
An attribute.
Base class for implementing primitive value attributes
A builder for a attribute model reference based on a QName
The BPMN auditing element
The BPMN auditing element
Allows to expose the id of the currently authenticated user,
his groups and his tenants to the process engine.
Represents an active authentication of a given identity (usually a user).
Servlet
Filter implementation responsible for populating the
Authentications.getCurrent() thread-local (ie.A provider to handle the authentication of
HttpServletRequests.Serves as DTO to hold the result of an authentication request performed
through an
AuthenticationProvider.Wrapper around current authentications.
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.
Dto for
AuthorizationExceptionContains 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.
Provides a way to define a back off between fetch and lock requests.
Thrown when you perform an illegal operation or the given data is invalid.
Exception resulting from a bad user request.
Provides Base64 encoding and decoding as defined by RFC 2045.
The BPMN baseElement element
The BPMN baseElement element
Provides HTTP Basic Authentication by using the request interceptor api
Represent username\password pair for user verification
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.
The default benchmark aggregator records the duration
Bindings, usually created by a
Tree.Utiliy class
Util class for manipulating bit-flag in ints.
class for providing Boolean value attributes.
Builder for building
BooleanAttributesTransform values of type
String into BooleanValue.A
PrimitiveValue corresponding to the Java type Boolean.Serializes booleans as long values.
The BPMN boundaryEvent element
The BPMN Boundary Event.
The BPMN boundaryEvent element
The DC bounds element
The DC bounds element
Provides access to the camunda BPMN model api.
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.
Convenience class to access only camunda *BPMN* related Assertions
PLUS helper methods.
Deployer responsible to parse BPMN 2.0 XML files and create the proper
ProcessDefinitionEntitys.The BPMNDI BPMNDiagram element
The BPMNDI BPMNDiagram element
The BPMNDI BPMNEdge element
The BPMNDI BPMNEdge element
Special exception that can be used to throw a BPMN Error from
JavaDelegates and expressions.Helper class handling the propagation of BPMN Errors.
The BPMNDI BPMNLabel element
The BPMNDI BPMNLabel element
The BPMNDI BPMNLabelStyle element
The BPMNDI BPMNLabelStyle element
Constants used in the BPMN 2.0 Language (DI + Semantic)
Interface implemented by all elements in a BPMN Model
Shared base class for all BPMN Model Elements.
A
RuntimeException in the Bpmn Model.Implemented by classes which provide access to the
BpmnModelInstance
and the currently executed FlowElement.A BPMN 2.0 Model
The Bpmn Model
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.
The parser used when parsing BPMN Files
Helper methods to reused for common parsing tasks.
The BPMNDI BPMNPlane element
The BPMNDI BPMNPlane element
Properties of bpmn elements.
The BPMNDI BPMNShape element
The BPMNDI BPMNShape element
Provides access to the Camunda Platform services.
Defines the bpm-platform subsystem for Wildfly 8+ application server
Provides the description and the implementation of the subsystem#add operation.
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
Tree builder.
Feature enumeration type.
The set of built-in exception codes the built-in
ExceptionCodeProvider
uses to assign a code to a ProcessEngineException.Qualifier annotation for injecting a business key:
Inspired by the CDI implemenation
Producer for the current business key.
Bean supporting contextual business process management.
Implementation of the BusinessProcessContext-scope.
Can be used to qualify events with details about a
ProcessDefinition:Signifies an event that is happening / has happened during the execution of a
business process.
The type of a business process event.
Declare a bean to be BusinessProcessScoped.
The BPMN businessRuleTask element
The BPMN businessRuleTask element
A byte array value field what load and save
ByteArrayEntity.A
PrimitiveValue corresponding to a Java byte array (byte[]).Simple (thread-safe) LRU cache.
This HistoryEventProducer is aware of the
DbEntityManager cache
and works in combination with the DbHistoryEventHandler.Cache control filter setting "Cache-Control: no-cache" on all GET requests.
A cached entity
Builds the caches for the
DeploymentCache.The BPMN callableElement element
The BPMN callableElement element
The BPMN callActivity element
Implementation of the BPMN 2.0 call activity
(limited currently to calling a subprocess and not (yet) a global task).
The BPMN callActivity element
Represents a callback which should be called after work was done.
The BPMN callConversation element
The BPMN callConversation element
Custom runtime exception that wraps a checked exception.
Inspired by:
https://groups.google.com/forum/#!msg/camunda-bpm-users/BQHdcLIivzs
/iNVix8GkhYAJ (Christoph Berg)
Return the full version string of the present Camunda codebase, or
null if it cannot be determined.Inspired by:
https://groups.google.com/forum/#!msg/camunda-bpm-users/BQHdcLIivzs
/iNVix8GkhYAJ (Christoph Berg)
The BPMN connector camunda extension element
The BPMN connectorId camunda extension element
The BPMN connectorId camunda extension element
The BPMN connector camunda extension element
The BPMN constraint camunda extension element
The BPMN constraint camunda extension element
Event class that is fired after Camunda engine startup.
The BPMN camundaEntry camunda extension element
The BPMN executionListener camunda extension element
The BPMN executionListener camunda extension element
The BPMN expression camunda extension element
The BPMN expression camunda extension element
The BPMN failedJobRetryTimeCycle camunda extension element
The BPMN failedJobRetryTimeCycle camunda extension element
The BPMN field camunda extension element
The BPMN field camunda extension element
The BPMN formData camunda extension element
The BPMN formData camunda extension element
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.
The BPMN formField camunda extension element
The BPMN formField camunda extension element
The BPMN formProperty camunda extension element
The BPMN formProperty camunda extension element
A
CamundaFormRef represents a reference to a deployed Camunda Form.A helper interface for camunda extension elements which
hold a generic child element like camunda:inputParameter,
camunda:outputParameter and camunda:entry.
A helper interface for camunda extension elements which
hold a generic child element like camunda:inputParameter,
camunda:outputParameter and camunda:entry.
The BPMN in camunda extension element
The CMMN in camunda extension element
The BPMN in camunda extension element
The BPMN inputOutput camunda extension element
The BPMN inputOutput camunda extension element
The BPMN inputParameter camunda extension element
The BPMN inputParameter camunda extension element
The BPMN camundaList extension element
The BPMN camundaMap extension element
The BPMN camundaMap extension element
The BPMN out camunda extension element
The CMMN out camunda extension element
The BPMN out camunda extension element
The BPMN outputParameter camunda extension element
The BPMN outputParameter camunda extension element
The BPMN potentialStarter camunda extension
The BPMN potentialStarter camunda extension
The BPMN properties camunda extension element
The BPMN properties camunda extension element
The BPMN property camunda extension element
The BPMN property camunda extension element
Class providing static methods returning all the resource classes provided by Camunda Platform.
The BPMN script camunda extension element
Custom Script Engine Manager that can execute custom logic:
The BPMN script camunda extension element
The BPMN string camunda extension element
The BPMN string camunda extension element
The BPMN taskListener camunda extension element
The BPMN taskListener camunda extension element
The BPMN validation camunda extension element
The BPMN validation camunda extension element
The BPMN value camunda extension element
The BPMN value camunda extension element
See CancelEndEventActivityBehavior: the cancel end event interrupts the scope and performs compensation.
The BPMN cancelEventDefinition element
The BPMN cancelEventDefinition element
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.
The BPMN catchEvent element
The BPMN catchEvent element
The BPMN categoryValue element
The BPMN categoryValue element
The BPMN categoryValueRef element of the BPMN tFlowElement type
Generic
ExecutionListener publishing events using the CDI event
infrastructure.BpmnParseListener registering the CdiEventListener for
distributing execution events using the cdi event infrastructureDeprecated.
ExpressionManager for resolving Cdi-managed beans.Exposes the CdiResolver in a multiple-applications, shared process engine context.
Resolver wrapping an instance of javax.el.ELResolver obtained from the
BeanManager.A single child element (child Element collection where
ChildElementCollection.getMaxOccurs() returns 1.A collection containing all or a subset of the child
elements of a given
ModelElementInstance.This collection is a view on an the children of a Model Element.
Represents a single Child Element (ie.
The BPMN childLaneSet element of the BPMN tLaneSet type
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.
Request context provides the data of the request and offers methods to change it
Client request interceptor makes it possible to apply changes to each request before it is sent to the http server
Convenience class to access camunda *BPMN* and *CMMN*
related Assertions PLUS helper methods.
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).
Provides access to the camunda cockpit core services.
The cockpit rest api exposed by the application.
A servlet context listener that bootstraps cockpit on a
running Camunda Platform.
The service provider interface (SPI) that must be provided by
a cockpit plugin.
The
CockpitRuntimeDelegate is a delegate to provide
the camunda cockpit plugin service.The BPMN collaboration element
The BPMN collaboration element
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.
Long running
Runnable adapterAbstractPlatformJobExecutor implementation delegating to a CommonJ WorkManager.An adapter for wrapping a Runnable as a CommonJ
Work instance.Util class for comparisons.
The BPMN compensateEventDefinition element
The BPMN compensateEventDefinition element
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.
Annotation signaling that a task is to be completed after the annotated
method returns.
Can be used to qualify events fired when a task is completed.
Interceptor for handling the CompleteTask-AnnotationThe BPMN 2.0 completionCondition element from the
tMultiInstanceLoopCharacteristics type
The BPMN 2.0 completionCondition element from the
tMultiInstanceLoopCharacteristics type
The BPMN 2.0 complexBehaviorDefinition element
The BPMN 2.0 complexBehaviorDefinition element
The BPMN complexGateway element
The BPMN complexGateway element
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.The BPMN condition element of the BPMN tConditionalEventDefinition type
Represents an interface for the condition event behaviors.
Represents the conditional event definition corresponding to the
ConditionalEvent defined by the BPMN 2.0 spec.
The BPMN conditionalEventDefinition element
The BPMN conditionalEventDefinition element
A fluent builder for defining conditional start event correlation
The BPMN conditionExpression element of the BPMN tSequenceFlow type
The BPMN conditionExpression element of the BPMN tSequenceFlow type
The BPMN condition element of the BPMN tConditionalEventDefinition type
Exception is thrown if the connection could not be established
Exposes a connector request as variableScope.
A constant parameter value.
Uses the
ProcessEngineService and exposes the default process engineUses the
BpmPlatform and exposes the default process engineRepresents a means for associating an execution with a context.
The BPMN conversation element
The BPMN conversationAssociation element
The BPMN conversationAssociation element
The BPMN conversation element
The BPMN conversationLink element
The BPMN conversationLink element
The BPMN conversationNode element
The BPMN conversationNode element
Defines the base API for the execution of an activity.
The result of a message correlation.
The BPMN correlationKey element
The BPMN correlationKey element
The BPMN correlationProperty element
The BPMN correlationPropertyBinding element
The BPMN correlationPropertyBinding element
The BPMN correlationProperty element
The BPMN correlationPropertyRef element of the BPMN tCorrelationKey type
The BPMN correlationPropertyRetrievalExpression element
The BPMN correlationPropertyRetrievalExpression element
The BPMN correlationSubscription element
The BPMN correlationSubscription element
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).Creates old engine for the rolling updates.
Can be used to qualify events fired when a task is created.
CommandContextCloseListener which releases a CDI Creational Context when the command context is closed.Provides a parser and evaluator for unix-like cron expressions.
Provides basic CSRF protection implementing a Same Origin Standard Header verification (step 1)
and a Synchronization Token with a cookie-stored token on the front-end.
Provides export functionality for exporting a
TabularResultSet
to CSV (Comma Separated Values).Allows to access executions and tasks of a managed process instance via
dependency injection.
Fluent builder to create a
CustomFunction.A data association (Input or Output) between a source and a target
The BPMN dataAssociation element
The BPMN dataAssociation element
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.
Maps a java object to the data format's internal representation and vice versa.
The BPMN dataInput element
The BPMN dataInputAssociation element
The BPMN dataInputAssociation element
The BPMN dataInput element
The BPMN element dataInputRef of the BPMN tInputSet type
The BPMN dataObject element
The BPMN dataObject element
The BPMN dataObjectReference element
The BPMN dataOutput element
The BPMN dataOutputAssociation element
The BPMN dataOutputAssociation element
The BPMN dataOutputRefs element of the BPMN tOutputSet type
The BPMN dataPath element of the BPMN tCorrelationPropertyBinding type
The BPMN dataState element
The BPMN dataStore element
The BPMN dataStore element
The BPMN dataStoreReference element
Utility for
DateTime that uses the JVM timezone
for date / time related operations.A
PrimitiveValue corresponding to the Java type Date.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
Application registering all resources.Default implementation of
AppPluginRegistry that loads Plugins
via the ServiceLoader facilities provided by the Java SE platform.Default ArtifactService implementation.
Provides the default authorizations for Camunda Platform.
Provides the default cache implementation for the deployment caches see
DeploymentCache.This is the default
CockpitRuntimeDelegate implementation that provides
the camunda cockpit plugin services (i.e.Default implementation of the business process association manager.
DmnDataTypeTransformerRegistry for the built-in DmnDataTypeTransformers.The default implementation of the DelegateInterceptor.
Validate a type against a list of allowed packages and classes.
Context which evaluates a decision on a given input
Represents the default priority provider for external tasks.
Register parseListener to setup failed job retry specification.
An incident handler that logs incidents of a certain type
as instances of
Incident to the engine database.Prepares JobExecutor and registers all known custom JobHandlers.
This is a simple implementation of the
JobExecutor using self-managed
threads for performing background work.Default implementation of
PermissionProviderWrapper for backwards-compatibility to
PluginRegistry.Represents a default priority provider, which contains some functionality to evaluate the priority.
File value is not available unless it is loaded actively
Initially
FileValue.getValue() returns null.The BPMN definitions element
The BPMN definitions element
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.
Implementation of
SqlSession delegating to a wrapped sessionImplements the
SqlSessionFactory delegating
to a wrapped SqlSessionFactoryDefines the different states of delegation that a task can be in.
Used for anything that needs a delete reason.
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.
Can be used to qualify events fired when a task is deleted.
Creates demo credentials to be used in the invoice showcase.
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.
The DI Diagram element
Stores waypoints of a diagram edge.
Stores the position of a waypoint of a diagram edge.
Represents a diagram node.
The DI DiagramElement element
The DI DiagramElement element
The DI Diagram element
Stores a two-dimensional graph layout.
Stores position and dimensions of a diagram node.
Implementation of a Bpmn BusinessRuleTask executing a DMN Decision.
Transform a value into a specific type.
Provide
DmnDataTypeTransformers for specific type names.A decision of the DMN Engine.
Event which represents the evaluation of a decision
A listener which will be notified after a decision
was evaluated.
Event which represents the evaluation of a decision with a literal expression.
Represents the decision logic of a decision.
Event which represents the evaluation of a decision.
Evaluates decisions with a specific kind of decision logic and generates the
result.
Container of
DmnDecisions which belongs to the same decision
requirements graph (i.e.
The result of one decision evaluation.
Represents the output entries (i.e., pairs of output name and value).
Exception throw for errors during the result creation of
a decision.
The result of one decision rule.
Event which represents the evaluation of a decision table
A listener which will be notified after a decision table
was evaluated.
The result of one decision table.
Context available during the DMN transformation
Handler to transform a DMN model element.
Registry of DMN model element transformers
A DMN engine which can parse DMN decision models
and evaluate decisions.
The configuration of a
DmnEngine.Modify the given DMN engine configuration so that the DMN engine can be used
from the process engine.
The base exception of the DMN Engine.
JUnit 5 Extension to create and inject a
DmnEngine into the test class.DMN engine metric collector which records the executed decision elements
since since its creation.
JUnit rule for
DmnEngine initialization.A evaluated decision rule.
The input for a evaluated decision.
The output for a evaluated decision.
Exception throw for errors during the evaluation of a decision.
The producer for DMN history events.
Exception throw if a hit policy is not applicable for a
decision result.
Handler for a DMN decision table hit policy.
Registry of hit policy handlers
This exception is thrown when a
DmnModelInstance is not found.Resolver for available script engines.
A transform of a DMN model instance
DMN Transformer which creates a
DmnTransform to transform a
DMN model instanceException throw for errors during the transformation of a decision.
Factory to create a
DmnTransform from a DmnTransformerListener for a DMN transformation
The definition of a type used in the DMN engine to
transform data
The BPMN documentation element
The BPMN documentation element
Encapsulates a
Document.Encapsulates
Element.Helper methods which abstract some gruesome DOM specifics.
Filters
Elements by their nodeName + namespaceUriFilter retaining only Nodes of type
Node.ELEMENT_NODEA
DomUtil.NodeListFilter allows to filter a NodeList,
retaining only elements in the list which match the filter.A
PrimitiveValue corresponding to the Java type Double.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.
The DI Edge element
Bootstrap for the Camunda Platform using a singleton EJB
Deployment Step that reads the bpm-platform.xml from the classpath
Common base class for writing EJB process applications.
A reference to an EJB process application.
Exposes the
ProcessApplicationService as EJB inside the container.Exposes the
ProcessEngineService as EJB inside the container.Adds an additional configuration before the engine is built
An Element.
Represents one XML element.
ElementReferenceBuilderImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
ElementReferenceCollectionBuilder<Target extends ModelElementInstance,Source extends ModelElementInstance>
ElementReferenceCollectionBuilderImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
ElementReferenceCollectionImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
Provider for Java Expression Language (EL) support.
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.
An empty variable context implementation which does
not allow to resolve any variables.
Annotation to bootstrap the External Task Client
Annotation that disables the
SpringProcessEngineConfiguration
auto-deploy feature and instead uses the required META-INF/processes.xml
as an indicator for resource scanning.Can be used to qualify events fired when an activity is ended / left
The BPMN endEvent element
The BPMN endEvent element
The BPMN endPoint element
The BPMN endPoint element
The BPMN interfaceRef element of the BPMN tParticipant type
Thrown if something went wrong during the engine execution (e.g., a persistence exception occurred).
This is a
RequestAuthorizer which authorizes all process engine api
requests based on the current authenticationThe engine rest api exposed by the application.
Compares operations by Entity type.
An attribute exposing an Enum value
Represents a BPMN Error definition, whereas
BpmnError represents an
actual instance of an Error.The BPMN error element
Provides a way to define a back off between fetch and lock requests.
The BPMN errorEventDefinition element
The BPMN errorEventDefinition element
The BPMN errorRef element of the BPMN tOperation type
Represents an 'escalation' element.
The BPMN escalation element
Represents an escalation event definition that reference an 'escalation' element.
The BPMN escalationEventDefinition element
The BPMN escalationEventDefinition element
Helper class handling the propagation of escalation.
The BPMN escalation element
Evaluates the decision with the given key or id.
Evaluates the decision table with the given key or id.
Evaluate a decision table using the DecisionService of the engine.
Evaluates the conditions to start processes by conditional start events
Deprecated.
The BPMN event element
The BPMN eventBasedGateway element
The BPMN eventBasedGateway element
The BPMN tEventBasedGatewayType simpleType
The BPMN eventDefinition element
The BPMN eventDefinition element
The BPMN eventDefinitionRef element of the BPMN tCatchEvent type
The BPMN event element
Properties controlling spring eventing.
Engine Plugin forwarding Camunda task, execution and history events as Spring Events.
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.Translates any
Throwable to a HTTP 500 error and a JSON response.The BPMN exclusiveGateway element
implementation of the Exclusive Gateway/XOR gateway/exclusive data-based gateway
as defined in the BPMN specification.
The BPMN exclusiveGateway element
Represents an executable script.
Represent a 'path of execution' in a process instance.
Deprecated.
Qualifier annotation for injecting the current executionId.
ExecutionListener recording the current execution id in the PerfTestRunContext
using the key PerfTestConstants.EXECUTION_ID.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.
Bean exposing the JCA implementation of the
ExecutorService as Stateless Bean.Provides an exponential backoff strategy.
Provides an exponential backoff strategy when an error occurs fetching external tasks.
The BPMN expression element
An
ExecutionListener that evaluates a Expression when notified.Expression factory implementation.
A profile provides a default set of language features that will define the builder's
behavior.
Class used to get hold of a
ExpressionFactory.Class responsible for handling Expression.getValue invocations
The BPMN expression element
Central manager for all expressions.
Expression node interface.
Class responsible for handling Expression.setValue() invocations.
The DI extension element of the DI DiagramElement type
The BPMN extension element
The BPMN extensionElements element
The DMN extensionElements element
The BPMN extensionElements element
The DMN extensionElements element
The DI extension element of the DI DiagramElement type
The BPMN extension element
Represents an external task
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.
Assertions for an
ExternalTask.Camunda external task client
A fluent builder to configure the Camunda client
External task client exception
Represents a base class for the external task commands.
Interface for a custom implementation of the handler, which is invoked for each fetched and locked task
Represents the logger for the external task.
Service that provides possibilities to interact with fetched and locked tasks.
Service that provides access to
ExternalTask instances.Annotation to subscribe the External Task Client to a topic.
Element of
ExternalTaskSubscription.processVariables()Exception thrown if a invalid type conversion occurs in a FEEL expression.
Provides one or more functions which can be used in an FEEL expression.
Engine to evaluate FEEL expressions.
Factory to create a instance of a
FeelEngine.Exception which is thrown if a error occurs during the
evaluation of a FEEL expression.
Exception thrown if an error occurs during a method invocation
in a FEEL expression.
Exception thrown if a method used in a FEEL expression is not available.
Exception thrown if a variable used in a FEEL expression is not available.
Exception thrown if the syntax of a FEEL expression is invalid.
SPI supposed to replace the default implementation of the long-polling fetch and lock handler
Simple JPA entity, id is set on a field.
Represents a field declaration in object form:
<field name='someField> <string ...
Valuetype to save files from byte arrays, inputstreams or just files as
process variables and retrieve them via an
InputStream.Utility to load and match filter rules.
Fix value type validation for ObjectTypeAttributeDefinition containing a map as value type.
Expression that always returns the same value when
getValue is
called.The BPMN flowElement element
The BPMN flowElement element
The BPMN flowNode element
Superclass for all 'connectable' BPMN 2.0 process elements: tasks, gateways and events.
The BPMN flowNode element
The BPMN flowNodeRef element of the BPMN tLane type
Walks the flow scope hierarchy upwards
The DC font element
The DC font element
The BPMN formalExpression element
The BPMN formalExpression element
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.The BPMN from element of the BPMN tAssignment type
Function node interface.
The BPMN gateway element
super class for all gateway activity implementations.
The BPMN tGatewayDirection simpleType
The BPMN gateway element
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.
Represents an task which generates metrics of an year.
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.
Command for retrieving start or task form keys.
The BPMN globalConversation element
The BPMN globalConversation element
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.
Partial implementation of the HAL link object as defined in
json-hal-06#section-5
A stateful linker which collects information about the links it creates.
A link resolver is capable of resolving a set of resources by Id.
Base class for implementing a HAL resource as defined in
json-hal-06#section-4
Command to handle an external task BPMN error.
Represents an abstract class for the handle of external task commands.
Base DTO class for Worker-related External Task operations.
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).
Represents the hit policy and the aggregator of a decision table.
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.Uses a
TabularResultSet and renders it as a Html Table.
Authenticates a request against the provided process engine's identity service by applying http basic authentication.
Automatically creates a session mutex when a HttpSession
is created.
The BPMN humanPerformer element
The BPMN humanPerformer element
Identifier node interface.
Transform the given value into untyped value.
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.IdsElementReferenceCollectionBuilderImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
IdsElementReferenceCollectionImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
Thrown if the webapp is configured incorrectly
Immutable representation of a 2-tuple of elements.
The BPMN Import element
The BPMN import element
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.
The BPMN inclusiveGateway element
Implementation of the Inclusive Gateway/OR gateway/inclusive data-based
gateway as defined in the BPMN specification.
The BPMN inclusiveGateway element
The BPMN incoming element of the BPMN tFlowNode type
The BPMN inMessageRef element of the BPMN tOperation type
The BPMN innerParticipantRef element of the BPMN tParticipantAssociation type
The BPMN 2.0 inputDataItem from the tMultiInstanceLoopCharacteristics type
The BPMN 2.0 inputDataItem from the tMultiInstanceLoopCharacteristics type
+-----------------+
| |
outer scope-----> inner scope |
| |
+-----------------+
The BPMN inputSet element
The BPMN inputSet element
The BPMN inputSetRefs element of the BPMN tOutputSet type
Expresses that the list of activities should be instantiated and optionally a transition
afterwards.
A
PrimitiveValue corresponding to the Java type Integer.The BPMN interactionNode interface
The BPMN interactionNode interface
The BPMN interface element
The BPMN interface element
The BPMN interfaceRef element of the BPMN tParticipant type
The BPMN intermediateCatchEvent element
The BPMN intermediateCatchEvent element
The BPMN intermediateThrowEvent element
The BPMN intermediateThrowEvent element
This class represents the structure of data describing Camunda internal
metrics and the technical environment in which Camunda is set-up.
This exception is used for any kind of errors that occur due to malformed
parameters in a Http query.
The context of an invocation.
Process Application exposing this application's resources the process engine.
The BPMN ioBinding element
The BPMN ioBinding element
Maps variables in and out of a variable scope.
An
IoParameter creates a variable
in a target variable scope.The BPMN inputOutputSpecification element
The BPMN IoSpecification element
The BPMN itemAwareElement element
The BPMN itemDefinition element
The BPMN tItemKind simple type
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.
Provides method abstractions to make our subsystem compatible with different JBoss versions.
The
ResourceAdapter responsible for bootstrapping the JcaExecutorServiceMBean Service delegating to the Jca ExecutorService
AbstractPlatformJobExecutor implementation delegating to a JCA WorkManager.An adapter for wrapping a Runnable as a JCA
Work instance.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.).
Provides the description and the implementation of the job-acquisition#add operation.
Provides the description and the implementation of the process-engine#remove operation.
Java API to the JobAcquisition deployment metadata
Implementation of the
JobAcquisitionXml SPI interfaceAssertions for a
Job.A 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 be implemented by a MessageDriven bean handling the execution of
a job.
Represents the activation of a
JobExecutionHandlerMessageDrivenBean implementation of the
JobExecutionHandler interfaceInterface to the component responsible for performing
background work (
Jobs).Installs the JobExecutor service into the container.
Provides the
JobExecutor related features of AbstractProcessEngineTestCase.Deployment Metadata for the JobExecutor Service.
Implementation of the
JobExecutorXmlThis actually simulates creation of a job in Camunda 7.0;
we use 7.3
Allows 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
AbstractTransactionInterceptorA simple implementation of
ElProvider using Juel.Expression 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.The DI Label element
The DI LabeledEdge element
The DI LabeledEdge element
The DI LabeledShape element
The DI LabeledShape element
The DI Label element
A single lane in a BPMN 2.0 LaneSet, currently only used internally for rendering the
diagram.
The BPMN lane element
The BPMN lane element
A BPMN 2.0 LaneSet, containg
Lanes, currently only used for
rendering the DI info.The BPMN laneSet element
The BPMN laneSet element
LazyDelegateFilter<T extends jakarta.servlet.Filter>
LazyDelegateFilter.InitHook<T extends jakarta.servlet.Filter>
This wrapper class should ensure that LDAP exceptions are wrapped as process engine exceptions
to avoid that error details are disclosed in the REST API.
Java Bean holding LDAP configuration
ProcessEnginePlugin providing Ldap Identity Provider supportLDAP
ReadOnlyIdentityProvider.Since multi-tenancy is not supported for the LDAP plugin, the query always
returns
0 or an empty list.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.
The BPMN linkEventDefinition element
The BPMN linkEventDefinition element
Represents an external task that was fetched and locked.
Deprecated.
since 7.4, use slf4j
A
PrimitiveValue corresponding to the Java type Long.The loopCardinality element from the tMultiInstanceLoopCharacteristics complex type
The loopCardinality element from the tMultiInstanceLoopCharacteristics
complex type
The BPMN loopCharacteristics element
The BPMN loopCharacteristics element
The BPMN 2.0 loopDataInputRef element of the BPMN 2.0
tMultiInstanceLoopCharacteristics type
The BPMN 2.0 loopDataOutputRef element of the BPMN 2.0
tMultiInstanceLoopCharacteristics type
JobExecutor implementation that utilises an application server's
managed thread pool to acquire and execute jobs.A
JobExecutor implementation that utilises a separate thread pool
to acquire and execute jobs.Factory bean registering a spring-managed process engine with the
BpmPlatform.Service for admin and maintenance operations on the process engine.
The BPMN manualTask element
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.
The BPMN manualTask element
A simple Service Container that delegates to the JVM's
MBeanServer.The BPMN message element
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.The BPMN messageEventDefinition element
The BPMN messageFlow element
The BPMN messageFlowAssociation element
The BPMN messageFlowAssociation element
The BPMN messageFlow element
The BPMN messageFlowRef element of the BPMN tConversationNode type
The BPMN message event
Declaration of a Message Job (Asynchronous continuation job)
The BPMN messagePath element of the BPMN tCorrelationPropertyRetrievalExpression type
The BPMNDI MessageVisibleKind simpleType
this code is taken almost (99.99%) verbatim from the Spring Integration
project's source code where it's a static
private inner class.
this code is taken almost verbatim from the Spring Integration
project's source code where it's a static
private inner class.
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.
A model contains all defined types and the relationship between them.
This builder is used to define and create a new model.
This builder is used to define and create a new model.
A model build operation allows to participate in a model
build phase and perform some resolution steps once all
types are defined.
Constants used in the model
An instance of a
ModelElementTypeBase class for implementing Model Elements.
A validator for model element instances.
An Exception in the Core XML Model.
A model contains all defined types and the relationship between them.
An instance of a model
ModelInstanceCache<InstanceType extends ModelInstance,DefinitionType extends ResourceDefinitionEntity>
An instance of a model
An exception during IO operations.
Thrown when an error is encountered during XML parsing
Thrown when an error is encountered during reference resolving.
Thrown in case a value cannot be converted to or from the requested type
Some Helpers useful when handling model elements.
Thrown when an error is encountered during the model validation.
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
This Processor creates implicit module dependencies for process applications
The BPMN monitoring element
The BPMN monitoring element
Represents a Process Application registered with the Msc
Service representing a managed process engine instance registered with the Msc.
Service responsible for starting / stopping a managed process engine inside the Msc
A
RuntimeContainerDelegate implementation for JBoss AS 7Abstract Multi Instance Behavior: used for both parallel and sequential
multi instance implementation.
The BPMN 2.0 tMultiInstanceFlowCondition simple type
The BPMN 2.0 multiInstanceLoopCharacteristics element type
The BPMN 2.0 multiInstanceLoopCharacteristics element
Custom implementation of Multipart Form Data which can be used for handling requests.
Dto representing a part in a multipart form.
Provides a
MessageBodyReader for MultipartFormData.This bean provides producers for the process engine services such
that the injection point can choose the process engine it wants to
inject by its name:
An Element.
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) queriesBasic node interface.
The DI Node element
The DI Node element
Node pretty printer for debugging purposes.
implementation 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.
Exception is thrown if the task has been canceled and therefore does not exist anymore
This exception is thrown, if an entity (case execution, case definition) is not found.
This is an empty service implementation illustrating how to use a plain
Java Class as a BPMN 2.0 Service Task delegate.
Exception is thrown when subscription has not yet been initialized
Exception is thrown when subscription has not yet been opened
This exception is thrown, if a given value is not valid.
Subscriptions for compensation start events must be migrated, similar to compensation boundary events.
Start Service for process applications that do not expose an EE Component View
(like
ServletProcessApplicationUntyped Null
Used to serialize untyped null values.
Arithmetic Operations as specified in chapter 1.7.
A typed value representing a Java Object.
Object wrapper expression.
The BPMN operation element
The BPMN operation element
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.The BPMN operationRef element of the BPMN tMessageEventDefinition type
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
The BPMN optionalInputRefs element of the BPMN tInputSet type
The BPMN optionalOutputRefs element of the BPMN tOutputSet type
The BPMN outerParticipantRef element of the BPMN tParticipantAssociation type
The BPMN outgoing element of the BPMN tFlowNode type
The BPMN outMessageRef of the BPMN tOperation type
The BPMN 2.0 outputDataItem from the tMultiInstanceLoopCharacteristics type
The BPMN 2.0 outputDataItem from the tMultiInstanceLoopCharacteristics type
+--------------+
| |
| inner scope ------> outer scope
| |
+--------------+
The BPMN outputSet element
The BPMN outputSet element
The BPMN outputSetRefs element of the BPMN tInputSet type
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.
The BPMN parallelGateway element
Implementation of the Parallel Gateway/AND gateway as definined in the BPMN
2.0 specification.
The BPMN parallelGateway element
Dto for
ParseException
The exception contains a list of errors and warning that occurred during
parsing.Detects and parses all META-INF/processes.xml files within the process application
and attaches the parsed Metadata to the operation context.
Handcrafted top-down parser.
Provide limited support for syntax extensions.
Parse exception type
The BPMN participant element
The BPMN participantAssociation element
The BPMN participantAssociation element
The BPMNDI ParticipantBandKind simpleType
The BPMN participant element
The BPMN participantMultiplicity element
The BPMN participantMultiplicity element
Object indicating that a
ProcessDefinitionImpl is a participant in a collaboration (pool).The BPMN participantRef element of the BPMN tConversationNode type
The BPMN partitionElement of the BPMN tLane type
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.
A
SecurityFilterRule that deleagates to a set of PathMatchersThe BPMN performer element
The BPMN performer element
A performance test.
Configuration of a performance test
JUnit rule allowing to load the performance test configuration from a file
A step in a performance test.
JUnit rule recording the performance test result
An individual run of a performance test.
Represents an individual run.
A step in a performance test.
Allows to follows the progress of a
PerfTestRun.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.The DI Plane element
The DI Plane element
A ServiceType is a collection of services that share a common name prefix.
Used by the
MscRuntimeContainerDelegate to create the jndi bindings Retrieves the List of ProcessEngines from an attached
ProcessesXml.Base class for the process engine test cases.
Deprecated.
Used to replace a plugin resource.
The DC point element
The DC point element
Annotation that can be placed on a method of a
ProcessApplication class.Operation step responsible for invoking the @
PostDeploy method of a
ProcessApplication class.The BPMN potentialOwner element
The BPMN potentialOwner element
Annotation that can be placed on a method of a
ProcessApplication class.Operation step responsible for invoking the @
PreUndeploy method of a
ProcessApplication class.Implementation of the primitive variable value types
Interface of a problem occurred during parsing
Dto for
Problem
The problem contains a list of element ids and other details for root
causing the issue.The BPMN process element
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.
This processor installs the process application into the container.
Service responsible for performing a deployment to the process engine and managing
the resulting
ProcessApplicationRegistration with the process engine.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.
Service installed for a process application module
This processor detects a user-provided component annotated with the
ProcessApplication-annotation.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 JNDIThis service is responsible for starting the
MscManagedProcessApplication service.Responsible for invoking
BpmPlatformPlugin.postProcessApplicationUndeploy(ProcessApplicationInterface)Checked exception thrown by a
ProcessApplicationReference if the referenced
process application is unavailable.Sets the ProcessApplicationInfo.PROP_SERVLET_CONTEXT_PATH property if this is
deployed as part of a WebApplication.
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.
Assertions for a
ProcessDefinition.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.
Provides the description and the implementation of the process-engine#add operation.
Servlet filter to plug in authentication.
Represents an exception in activiti cdi.
Indicates that the given bean is an process engine handler.
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.
Translates any
ProcessEngineException to a HTTP 500 error and a JSON response.Junit 5 Extension to create and inject a
ProcessEngine into the test class.Represents information about the initialization of the process engine.
Base class for implementing a process engine performance test
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 descriptorA simple provider SPI used to locate a process engine object.
Provides the description and the implementation of the process-engine#remove operation.
Convenience for ProcessEngine and services initialization in the form of a
JUnit rule.
Runner that ensures closing process engines after test run.
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.Makes the managed process engine and the provided services available for injection
Deployment Unit Processor that creates process engine services for each
process engine configured in a
processes.xml fileConvenience for ProcessEngine and services initialization in the form of a JUnit base class.
Convenience class to access all available Camunda Platform related
Assertions PLUS helper methods.
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
Detects and processes all META-INF/processes.xml files that are visible from the module
classloader of the
DeploymentUnit. Retrieves the List of ProcessEngines from an attached
ProcessesXml.Deployment operation responsible for stopping all process engines started by the deployment.
when used on a method parameter, this triggers the injection of the current processId.
The BPMN process element
Represents one execution of a
ProcessDefinition.Assertions for a
ProcessInstance.Qualifier annotation for injecting the id of the current process instance.
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.
Represents a process instance dto extension dto that contains latest variables.
Simply wraps a modification builder because their API is equivalent.
binds variables to a currently executing Activiti business process (a
ProcessInstance).Proxies beans with methods annotated with
StartProcess.MethodInterceptor that starts a business process
as a result of a successful method invocation.AOP advice for methods annotated with (by default)
StartProcess.The BPMN tProcessType simple type
Annotation for qualifying injection points such that process variables are
injected.
Annotation for qualifying injection points such that local process variables are
injected.
Allows to expose the local process variables of the current business process as a
java.util.Map<String,Object>
Annotation for qualifying injection points such that local process variables are
injected.
Allows to expose the process variables of the current business process as a
java.util.Map<String,Object>
Allows to access the process variables of a managed process instance.
Annotation for qualifying injection points such that process variables are
injected.
Starts the process with a parallel gateway, service task and user task on the old engine.
Starts the process with a parallel gateway and user task's on the old engine.
Starts the process with a user task on the old engine.
Starts the process with a user task on the old engine.
This class represents the data structure of information about the Camunda
product.
Provides product information data loaded from a *.properties file.
Utility class for performing programmatic bean lookups.
Properties that maps property keys to values.
Adds camunda.bpm.version properties to environment.
The BPMN property element
Contains data about a property change.
The BPMN property element
Key of a typed property.
Key of a list property.
Key of a map property.
Parse listener adding provided execution and task listeners.
Event handler publishing history events as Spring Events.
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
QNameElementReferenceBuilderImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
QNameElementReferenceCollectionBuilderImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
QNameElementReferenceCollectionImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
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.
Typed query parameters for usage in cockpit plugins
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.The BPMN receiveTask element
A receive task is a wait state that waits for the receival of some message.
The BPMN receiveTask element
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).
The BPMN relationship element
The BPMN tRelationshipDirection type
The BPMN relationship element
Represents a instance which will be removed by a migration, i.e.
The BPMN rendering element
The BPMN rendering element
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.
The interface for request authorizers.
A request matcher that matches uris compatible to the JAX-RS syntax
and extracts the arguments on match.
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.
The BPMN resource element
The BPMN resourceAssignmentExpression element
The BPMN resourceAssignmentExpression element
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.
The BPMN resource element
The BPMN resourceParameter element
The BPMN resourceParameterBinding element
The BPMN resourceParameterBinding element
The BPMN resourceParameter element
The BPMN resourceRef element of the BPMN tResourceRole type
This a report created during a parsing.
Resource report created during resource parsing
The BPMN resourceRole element
The BPMN resourceRole element
The set of built-in
Resource names.Thrown when a request from the engine's REST API fails.
Translates
RestExceptions to error responses according to the status that is set in the exception.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).Contains the rolling update tags which are used for the scenarios and test cases.
The BPMN rootElement element
The BPMN rootElement element
Simple root property resolver implementation.
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
RuntimeContainerHandcrafted scanner.
Scan exception type
Symbol type
Log 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.
this class was copied wholesale from Spring 3.1's RefreshScope, which Dave Syer wrote.
The BPMN script element
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.The BPMN script element
Manager for JSR-223
ScriptEngine handling.The scripting environment contains scripts that provide an environment to
a user provided script.
The BPMN scriptTask element
ActivityBehavior implementation of the BPMN 2.0 script task.The BPMN scriptTask element
A
TaskListener which invokes a ExecutableScript when notified.Makes it possible to use scripts in
IoParameter mappings.Simple filter implementation which delegates to a list of
FilterRules,
evaluating their SecurityFilterRule#setAuthorized(org.camunda.bpm.webapp.impl.security.filter.AppRequest) condition
for the given request.POJO representing the configuration of the security filter
This interface is used by the
SecurityFilter to authorize incoming requests.Allows to take screenshots in case of an selenium test error.
The BPMN sendTask element
The BPMN sendTask element
The BPMN sequenceFlow element
The BPMN sequenceFlow element
AcquireJobsRunnable able to serve multiple process engines.A
TypedValue for which a serialized value can be obtained and specifiedRepresents a serialization data format.
A
Future implementation backed by a LifecycleListenerAll ServiceName references run through here.
The BPMN serviceTask element
ActivityBehavior used when 'delegateExpression' is used
for a serviceTask.ActivityBehavior that evaluates an expression when executed.
The BPMN serviceTask element
Service Listener that adds / removes services to / from a collection as they
are added / removed to the service controller.
The service types managed by this container.
With Camunda Platform 7.13 we introduced the application path prefix /camunda to Spring Boot.
Common logic that is used in servlet filters.
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.
Jax RS resource allowing to perform the setup steps.
PasswordEncryptor implementation using base64 encoded SHA-512 password hashesPasswordEncryptor implementation using base64 encoded SHA password hashesThe DI Shape element
The DI Shape element
A
PrimitiveValue corresponding to the Java type Short.The BPMN signal element
Represents a bpmn signal definition
The BPMN signalEventDefinition element
The BPMN signalEventDefinition element
Fluent builder to notify the process engine that a signal event has been
received.
The BPMN signal element
Simple context implementation.
For mybatis
ExecutorType.SIMPLEThe SimpleFormFieldType can be used when the form value and the model value are equal.
Simple resolver implementation.
MPSC Condition implementation.
Maps the decision result to a single typed entry.
Maps the decision result to pairs of output name and untyped entries.
An
VariableContext allowing to resolve a single variable only.The BPMN source element of the BPMN tRelationship and tLinkEventDefinition type
A script which is provided as source code.
The BPMN sourceRef element of the BPMN tDataAssociation type
Java Bean holding Spin configuration properties.
A FunctionMapper which resolves the Spin functions for Expression Language.
Implementation of a
TypedValueSerializer for ObjectValues using a
Spin-provided DataFormat to serialize and deserialize java objects.Resolves Spin Environment Scripts.
ResolverFactory and Resolver classes to make the beans
managed by the Spring container available in scriptingConvenience class that specializes
AbstractProcessEnginePlugin to
use SpringProcessEngineConfiguration (to save casting).Runtime exception that is the superclass of all exceptions in the spring boot started.
ExpressionManager that exposes the full application-context or a limited set
of beans in expressions.
Spring External Task Client Exception
This is a spring based implementation of the
JobExecutor using spring abstraction TaskExecutor
for performing background task execution.Process Application implementation to be used in a Spring Application.
ProcessApplicationElResolver implementation providing support for the Spring Framework.
This is bean-name-aware extension of the
AbstractProcessEnginePlugin allowing anonymous
classes get logged correctly when processed.Exposes all camunda process engine services as beans.
Process Application to be used in a Spring Web Application.
Represents a topic subscription of the External Task Client.
Aggregates the results from a Sql Statement Test run.
Aggregates the results from a Sql Statement Test run.
Default in memory configuration, pre-configured with mock, dbSchema and metrics.
Can be used to qualify events fired when an activity is started
The BPMN startEvent element
The BPMN startEvent element
Specific
FormData for starting a new process instance.Deployment operation responsible registering a service which represents a Proxy to the
JCA-Backed
ExecutorServiceDeployment 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
Starts a new process instance after the annotated method returns.
this annotation instructs the component model to start an Activiti business process on
sucessful invocation of a method that's annotated with it.
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.
implementation of the
StartProcess annotationVariable-scope only used to resolve variables when NO execution is active but
expression-resolving is needed.
indicates that a method is to be enlisted as a handler for a given BPMN state
this class is responsible for registering the other
BeanFactoryPostProcessors
and BeanFactoryPostProcessors.PerfTestWatcher performing statement logging.ProcessEnginePlugin activating statement logging.
This SqlSession wraps an actual SqlSession and logs executed sql statements.
DelegatingSqlSessionFactory wrapping the created sessions using a {@link StatementLogSqlSession.Deployment operation responsible for stopping a service which represents a Proxy to the
JCA-Backed
ExecutorServiceDeployment 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.
Base class for String attributes
Transform values of type
Object into StringValue.Implementations are used to convert http parameters from string to java types.
Converts String to and from bytes using the encodings required by the Java specification.
A
PrimitiveValue corresponding to the Java type String.IdGenerator implementation based on the current time and the ethernet
address of the machine it is running on.Setters are only needed to create stub results.
The DI Style element
The DI Style element
The BPMN subConversation element
The BPMN subConversation element
The BPMN subProcess element
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.
The BPMN subProcess element
Event to be published after the
SpringTopicSubscription was initialized.*Supported* refers to whether an activity instance of a certain activity type can be migrated.
The BPMN supportedInterfaceRef element of the BPMN tCallableElement type
Validator for events that passively wait for an event, i.e.
The BPMN supports element of the BPMN tProcess type
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
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.A result aggregator is used to aggregate the results of a
performance testsuite run as a table.
Holds the aggregated results of a performance testsuite.
Can be used to qualify events fired when a transition is taken
The BPMN target element of the BPMN tRelationship type
The BPMN targetRef element of the BPMN tDataAssociation type
Represents one task for a human user.
The BPMN task element
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.
Assertions for a
Task.Container for task definition information gathered at parsing time.
Specific
FormData for completing a task.Qualifier annotation for injecting the current taskId.
specifies which parameter is a task id
TaskListener recording the current task id in the PerfTestRunContext
using the key PerfTestConstants.TASK_ID.The BPMN task element
The tasklist application.
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
TaskListenersSPI inteface for plugins to the tasklist webapplication.
The tasklist application service runtime delegate.
The 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.Utility methods to manipulate the Current Thread Context Classloader
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 BPMN terminateEventDefinition element
The BPMN terminateEventDefinition element
Sets up scenarios for rolling updates.
Sets up scenarios for migration from 7.3.0
Creates process instances with the new engine for the rolling updates.
Uses the
BpmPlatform and exposes the default process engineThe BPMN 2.0 text element from the tTextAnnotation complex type
The BPMN 2.0 textAnnotation element
The BPMN 2.0 textAnnotation element
The BPMN 2.0 text element from the tTextAnnotation complex type
The activity behavior for an intermediate throwing escalation event and an escalation end event.
The BPMN throwEvent element
The BPMN throwEvent element
Defines activity behavior for signal end event and intermediate throw signal event.
The BPMN timeCycle element of the BPMN tTimerEventDefinition type
The BPMN timeDuration element of the BPMN tTimerEventDefinition type
The BPMN timeDate element of the BPMN tTimerEventDefinition type
The BPMN timeDate element of the BPMN tTimerEventDefinition type
The BPMN timeDuration element of the BPMN tTimerEventDefinition type
The BPMN timeDuration element of the BPMN tTimerEventDefinition type
The BPMN timerEventDefinition element
The BPMN timerEventDefinition element
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.The BPMN to element of the BPMN tAssignment type
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.
Subscription to a topic
A fluent builder to configure the topic subscription
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.
The BPMN transformation element of the BPMN tDataAssociation type
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.
Parsed expression, usually created by a
TreeBuilder.Tree builder interface.
Exception type thrown in build phase (scan/parse).
Tree cache interface.
A method expression is ready to be evaluated (by calling either
TreeMethodExpression.invoke(ELContext, Object[]) or TreeMethodExpression.getMethodInfo(ELContext)).Tree store class.
A value expression is ready to be evaluated (by calling either
TreeValueExpression.getType(ELContext), TreeValueExpression.getValue(ELContext), TreeValueExpression.isReadOnly(ELContext)
or TreeValueExpression.setValue(ELContext, Object).A visitor for
SingleReferenceWalker.Provokes misbehaving error propagation that none of the other cases triggers
This
CommandContextFactory allows to explicitly pass in a TransactionContextFactory.Type Conversions as described in EL 2.1 specification (section 1.17).
Detects the canonical type string of a supplied object
A
TypedValue is a value with additional type information (the ValueType).A field what provide a typed version of a value.
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
Exception is thrown in case the HTTP status code is not known by the client.
Unlock job.
Allows to unlock users.
Exception thrown if a user attempts to perform an unsupported
model operation.
Used when the type of an object has not been specified by the user and
needs to be autodetected.
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.
UriElementReferenceBuilderImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
UriElementReferenceCollectionBuilderImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
UriElementReferenceCollectionImpl<Target extends ModelElementInstance,Source extends ModelElementInstance>
Represents a user, used in
IdentityService.An authentication for a user
Jax-Rs resource allowing users to authenticate with username and password
specifies which parameter is a user id
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.Exposes the
UserOperationLogQuery as REST service.Allows programmatic querying of
UserContains the possible properties that can be used by the
UserQuery.The BPMN userTask element
activity implementation for the user task.
The BPMN userTask element
An individual validation result.
Object passed to the
ModelElementValidator to collect validation results.SPI which can be implemented to print out a summary of a validation result.
Object in which the results of a model validation are collected.
Validators must be equal (in terms of
#equals(Object)) if they validate
the exact same thing.Exception is thrown when a value could not be mapped
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.
A context for variables.
Deprecated.
A
VariableInstance represents a variable in the execution of
a process instance.Reads a list of
VariableQueryParameterDtos from a single parameter.A Map of variables.
This class is the entry point to the process engine's typed variables API.
A set of builtin serialization dataformat constants.
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.The DI waypoint element of the DI Edge type
The DI waypoint element of the DI Edge type
The welcome application.
The rest api exposed by the welcome application
SPI interface for plugins to the welcome webapplication.
The welcome application service runtime delegate.
The BPMN whileExecutingInputRefs of the BPMN tInputSet type
The BPMN whileExecutingOutputRefs element of the BPMN tOutputSet type
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.
Thrown when a Model Element is added to the wrong document
A XML importer
BpmnExecutionContext