protected void initializeEntityCache() {
final JobExecutorContext jobExecutorContext = Context.getJobExecutorContext();
final ProcessEngineConfigurationImpl processEngineConfiguration =
Context.getProcessEngineConfiguration();
if (processEngineConfiguration != null
&& processEngineConfiguration.isDbEntityCacheReuseEnabled()
&& jobExecutorContext != null) {
dbEntityCache = jobExecutorContext.getEntityCache();
if (dbEntityCache == null) {
dbEntityCache = new DbEntityCache(processEngineConfiguration.getDbEntityCacheKeyMapping());
jobExecutorContext.setEntityCache(dbEntityCache);
}
} else {
if (processEngineConfiguration != null) {
dbEntityCache = new DbEntityCache(processEngineConfiguration.getDbEntityCacheKeyMapping());
} else {
dbEntityCache = new DbEntityCache();
}
}
}
public ByteArrayEntity getByteArrayValue() {
if ((byteArrayValue == null) && (byteArrayId != null)) {
// no lazy fetching outside of command context
if (Context.getCommandContext() != null) {
byteArrayValue =
Context.getCommandContext()
.getDbEntityManager()
.selectById(ByteArrayEntity.class, byteArrayId);
}
}
return byteArrayValue;
}
@Override
public List<ProcessDefinition> executeList(CommandContext commandContext, Page page) {
checkQueryOk();
List<ProcessDefinition> list =
commandContext
.getProcessDefinitionManager()
.findProcessDefinitionsByQueryCriteria(this, page);
for (ProcessDefinition processDefinition : list) {
BpmnModelInstance bpmnModelInstance =
Context.getProcessEngineConfiguration()
.getDeploymentCache()
.findBpmnModelInstanceForProcessDefinition(
(ProcessDefinitionEntity) processDefinition);
ModelElementInstance processElement =
bpmnModelInstance.getModelElementById(processDefinition.getKey());
if (processElement != null) {
Collection<Documentation> documentations =
processElement.getChildElementsByType(Documentation.class);
List<String> docStrings = new ArrayList<String>();
for (Documentation documentation : documentations) {
docStrings.add(documentation.getTextContent());
}
ProcessDefinitionEntity processDefinitionEntity =
(ProcessDefinitionEntity) processDefinition;
processDefinitionEntity.setProperty(
BpmnParse.PROPERTYNAME_DOCUMENTATION, BpmnParse.parseDocumentation(docStrings));
}
}
return list;
}
public void deleteHistoricProcessInstanceById(String historicProcessInstanceId) {
if (historyLevel > ProcessEngineConfigurationImpl.HISTORYLEVEL_NONE) {
CommandContext commandContext = Context.getCommandContext();
HistoricProcessInstanceEntity historicProcessInstance =
findHistoricProcessInstance(historicProcessInstanceId);
commandContext
.getHistoricDetailManager()
.deleteHistoricDetailsByProcessInstanceId(historicProcessInstanceId);
commandContext
.getHistoricVariableInstanceManager()
.deleteHistoricVariableInstanceByProcessInstanceId(historicProcessInstanceId);
commandContext
.getHistoricActivityInstanceManager()
.deleteHistoricActivityInstancesByProcessInstanceId(historicProcessInstanceId);
commandContext
.getHistoricTaskInstanceManager()
.deleteHistoricTaskInstancesByProcessInstanceId(historicProcessInstanceId);
getDbSqlSession().delete(historicProcessInstance);
}
}
public Void execute(CommandContext commandContext) {
if (messageName == null) {
throw new ProcessEngineException("messageName cannot be null");
}
CorrelationHandler correlationHandler =
Context.getProcessEngineConfiguration().getCorrelationHandler();
CorrelationSet correlationSet = new CorrelationSet(businessKey, correlationKeys);
Execution matchingExecution =
correlationHandler.correlateMessageToExecution(commandContext, messageName, correlationSet);
ProcessDefinition matchingDefinition =
correlationHandler.correlateMessageToProcessDefinition(commandContext, messageName);
if (matchingExecution != null && matchingDefinition != null) {
throw new ProcessEngineException(
"An execution and a process definition match the correlation.");
}
if (matchingExecution != null) {
triggerExecution(commandContext, matchingExecution);
return null;
}
if (matchingDefinition != null) {
instantiateProcess(commandContext, matchingDefinition);
return null;
}
throw new ProcessEngineException("Could not correlate message " + messageName);
}
protected MessageCorrelationResult tryCorrelateMessageToProcessDefinition(
CommandContext commandContext, String messageName, CorrelationSet correlationSet) {
MessageEventSubscriptionEntity messageEventSubscription =
commandContext
.getEventSubscriptionManager()
.findMessageStartEventSubscriptionByName(messageName);
if (messageEventSubscription == null || messageEventSubscription.getConfiguration() == null) {
return null;
} else {
DeploymentCache deploymentCache =
Context.getProcessEngineConfiguration().getDeploymentCache();
String processDefinitionId = messageEventSubscription.getConfiguration();
ProcessDefinitionEntity processDefinition =
deploymentCache.findDeployedProcessDefinitionById(processDefinitionId);
if (processDefinition == null) {
LOGGER.log(
Level.FINE,
"Found event subscription with {0} but process definition {1} could not be found.",
new Object[] {messageEventSubscription, processDefinitionId});
return null;
} else {
return MessageCorrelationResult.matchedProcessDefinition(
processDefinition, messageEventSubscription.getActivityId());
}
}
}
/** @return true if the passed-in user is currently authenticated */
protected boolean isAuthenticatedUser(UserEntity user) {
if (user.getId() == null) {
return false;
}
return user.getId()
.equals(
org.camunda.bpm.engine.impl.context.Context.getCommandContext()
.getAuthenticatedUserId());
}
protected void deleteTask(String taskId) {
TaskEntity task = Context.getCommandContext().getTaskManager().findTaskById(taskId);
if (task != null) {
if (task.getExecutionId() != null) {
throw new ProcessEngineException(
"The task cannot be deleted because is part of a running process");
}
String reason =
(deleteReason == null || deleteReason.length() == 0)
? TaskEntity.DELETE_REASON_DELETED
: deleteReason;
task.delete(reason, cascade);
} else if (cascade) {
Context.getCommandContext()
.getHistoricTaskInstanceManager()
.deleteHistoricTaskInstanceById(taskId);
}
}
protected String getDnForUser(String userId) {
LdapUserEntity user =
(LdapUserEntity)
createUserQuery(org.camunda.bpm.engine.impl.context.Context.getCommandContext())
.userId(userId)
.singleResult();
if (user == null) {
return "";
} else {
return user.getDn();
}
}
protected String getDnForGroup(String groupId) {
LdapGroupEntity group =
(LdapGroupEntity)
createGroupQuery(org.camunda.bpm.engine.impl.context.Context.getCommandContext())
.groupId(groupId)
.singleResult();
if (group == null) {
return "";
} else {
return group.getDn();
}
}
public void deleteByteArrayValue() {
if (byteArrayId != null) {
// the next apparently useless line is probably to ensure consistency in the DbSqlSession
// cache,
// but should be checked and docked here (or removed if it turns out to be unnecessary)
getByteArrayValue();
Context.getCommandContext().getByteArrayManager().deleteByteArrayById(this.byteArrayId);
byteArrayId = null;
}
}
/** customized insert behavior for HistoricVariableUpdateEventEntity */
protected void insertHistoricVariableUpdateEntity(
HistoricVariableUpdateEventEntity historyEvent) {
DbSqlSession dbSqlSession = getDbSqlSession();
// insert update only if history level = FULL
int historyLevel = Context.getProcessEngineConfiguration().getHistoryLevel();
if (historyLevel == ProcessEngineConfigurationImpl.HISTORYLEVEL_FULL) {
// insert byte array entity (if applicable)
byte[] byteValue = historyEvent.getByteValue();
if (byteValue != null) {
ByteArrayEntity byteArrayEntity =
new ByteArrayEntity(historyEvent.getVariableName(), byteValue);
Context.getCommandContext().getDbSqlSession().insert(byteArrayEntity);
historyEvent.setByteArrayId(byteArrayEntity.getId());
}
dbSqlSession.insert(historyEvent);
}
// always insert/update HistoricProcessVariableInstance
if (HistoryEvent.VARIABLE_EVENT_TYPE_CREATE.equals(historyEvent.getEventType())) {
HistoricVariableInstanceEntity persistentObject =
new HistoricVariableInstanceEntity(historyEvent);
dbSqlSession.insert(persistentObject);
} else if (HistoryEvent.VARIABLE_EVENT_TYPE_UPDATE.equals(historyEvent.getEventType())) {
HistoricVariableInstanceEntity historicVariableInstanceEntity =
dbSqlSession.selectById(
HistoricVariableInstanceEntity.class, historyEvent.getVariableInstanceId());
historicVariableInstanceEntity.updateFromEvent(historyEvent);
} else if (HistoryEvent.VARIABLE_EVENT_TYPE_DELETE.equals(historyEvent.getEventType())) {
HistoricVariableInstanceEntity historicVariableInstanceEntity =
dbSqlSession.selectById(
HistoricVariableInstanceEntity.class, historyEvent.getVariableInstanceId());
if (historicVariableInstanceEntity != null) {
historicVariableInstanceEntity.delete();
}
}
}
protected void invokeVariableListeners(boolean includeCustomerListeners) {
Queue<VariableEvent> variableEventsQueue = getVariableEventQueue();
while (!variableEventsQueue.isEmpty()) {
// do not remove the event yet, as otherwise new events will immediately be dispatched
VariableEvent nextEvent = variableEventsQueue.peek();
CmmnExecution sourceExecution = (CmmnExecution) nextEvent.getSourceScope();
DelegateCaseVariableInstanceImpl delegateVariable =
DelegateCaseVariableInstanceImpl.fromVariableInstance(nextEvent.getVariableInstance());
delegateVariable.setEventName(nextEvent.getEventName());
delegateVariable.setSourceExecution(sourceExecution);
Map<String, List<VariableListener<?>>> listenersByActivity =
sourceExecution
.getActivity()
.getVariableListeners(delegateVariable.getEventName(), includeCustomerListeners);
CmmnExecution currentExecution = sourceExecution;
while (currentExecution != null) {
if (currentExecution.getActivityId() != null) {
List<VariableListener<?>> listeners =
listenersByActivity.get(currentExecution.getActivityId());
if (listeners != null) {
delegateVariable.setScopeExecution(currentExecution);
for (VariableListener<?> listener : listeners) {
try {
CaseVariableListener caseVariableListener = (CaseVariableListener) listener;
CaseVariableListenerInvocation invocation =
new CaseVariableListenerInvocation(
caseVariableListener, delegateVariable, currentExecution);
Context.getProcessEngineConfiguration()
.getDelegateInterceptor()
.handleInvocation(invocation);
} catch (Exception e) {
throw LOG.invokeVariableListenerException(e);
}
}
}
}
currentExecution = currentExecution.getParent();
}
// finally remove the event from the queue
variableEventsQueue.remove();
}
}
// variable listeners
public void dispatchEvent(VariableEvent variableEvent) {
boolean invokeCustomListeners =
Context.getProcessEngineConfiguration().isInvokeCustomVariableListeners();
Map<String, List<VariableListener<?>>> listeners =
getActivity().getVariableListeners(variableEvent.getEventName(), invokeCustomListeners);
// only attempt to invoke listeners if there are any (as this involves resolving the upwards
// execution hierarchy)
if (!listeners.isEmpty()) {
getCaseInstance().queueVariableEvent(variableEvent, invokeCustomListeners);
}
}
public ProcessDefinitionEntity findDeployedLatestProcessDefinitionByKey(
String processDefinitionKey) {
ProcessDefinitionEntity processDefinition =
Context.getCommandContext()
.getProcessDefinitionManager()
.findLatestProcessDefinitionByKey(processDefinitionKey);
if (processDefinition == null) {
throw new ProcessEngineException(
"no processes deployed with key '" + processDefinitionKey + "'");
}
processDefinition = resolveProcessDefinition(processDefinition);
return processDefinition;
}
public TaskEntity createTask(TaskDecorator taskDecorator) {
TaskEntity task = TaskEntity.createAndInsert(this);
setTask(task);
taskDecorator.decorate(task, this);
Context.getCommandContext().getHistoricTaskInstanceManager().createHistoricTask(task);
// All properties set, now firing 'create' event
task.fireEvent(TaskListener.EVENTNAME_CREATE);
return task;
}
public Void execute(CommandContext commandContext) {
if (deploymentIds == null) {
throw new ProcessEngineException("Deployment Ids cannot be null.");
}
commandContext.getAuthorizationManager().isCamundaAdmin();
Context.getProcessEngineConfiguration()
.getProcessApplicationManager()
.unregisterProcessApplicationForDeployments(deploymentIds, removeProcessesFromCache);
return null;
}
public DecisionRequirementsDefinition execute(CommandContext commandContext) {
ensureNotNull("decisionRequirementsDefinitionId", decisionRequirementsDefinitionId);
DeploymentCache deploymentCache = Context.getProcessEngineConfiguration().getDeploymentCache();
DecisionRequirementsDefinitionEntity decisionRequirementsDefinition =
deploymentCache.findDeployedDecisionRequirementsDefinitionById(
decisionRequirementsDefinitionId);
for (CommandChecker checker :
commandContext.getProcessEngineConfiguration().getCommandCheckers()) {
checker.checkReadDecisionRequirementsDefinition(decisionRequirementsDefinition);
}
return decisionRequirementsDefinition;
}
protected Integer getJobDefinitionPriority(
ExecutionEntity execution, JobDeclaration<?> jobDeclaration) {
String jobDefinitionId = jobDeclaration.getJobDefinitionId();
if (jobDefinitionId != null) {
JobDefinitionEntity jobDefinition =
Context.getCommandContext().getJobDefinitionManager().findById(jobDefinitionId);
if (jobDefinition != null) {
return jobDefinition.getJobPriority();
}
}
return null;
}
public UserOperationLogContextEntryBuilder inContextOf(JobDefinitionEntity jobDefinition) {
entry.setJobDefinitionId(jobDefinition.getId());
entry.setProcessDefinitionId(jobDefinition.getProcessDefinitionId());
entry.setProcessDefinitionKey(jobDefinition.getProcessDefinitionKey());
if (jobDefinition.getProcessDefinitionId() != null) {
ProcessDefinitionEntity processDefinition =
Context.getProcessEngineConfiguration()
.getDeploymentCache()
.findDeployedProcessDefinitionById(jobDefinition.getProcessDefinitionId());
entry.setDeploymentId(processDefinition.getDeploymentId());
}
return this;
}
public ProcessDefinitionEntity findDeployedProcessDefinitionById(String processDefinitionId) {
if (processDefinitionId == null) {
throw new ProcessEngineException("Invalid process definition id : null");
}
ProcessDefinitionEntity processDefinition =
Context.getCommandContext()
.getProcessDefinitionManager()
.findLatestProcessDefinitionById(processDefinitionId);
if (processDefinition == null) {
throw new ProcessEngineException(
"no deployed process definition found with id '" + processDefinitionId + "'");
}
processDefinition = resolveProcessDefinition(processDefinition);
return processDefinition;
}
public void setByteArrayValue(byte[] bytes) {
deleteByteArrayValue();
ByteArrayEntity byteArrayValue = null;
if (bytes != null) {
byteArrayValue = new ByteArrayEntity(valueFields.getName(), bytes);
Context.getCommandContext().getDbEntityManager().insert(byteArrayValue);
}
this.byteArrayValue = byteArrayValue;
if (byteArrayValue != null) {
this.byteArrayId = byteArrayValue.getId();
} else {
this.byteArrayId = null;
}
}
public ProcessDefinitionEntity findDeployedProcessDefinitionByKeyAndVersion(
String processDefinitionKey, Integer processDefinitionVersion) {
ProcessDefinitionEntity processDefinition =
(ProcessDefinitionEntity)
Context.getCommandContext()
.getProcessDefinitionManager()
.findProcessDefinitionByKeyAndVersion(
processDefinitionKey, processDefinitionVersion);
if (processDefinition == null) {
throw new ProcessEngineException(
"no processes deployed with key = '"
+ processDefinitionKey
+ "' and version = '"
+ processDefinitionVersion
+ "'");
}
processDefinition = resolveProcessDefinition(processDefinition);
return processDefinition;
}
public void removeDeployment(String deploymentId) {
// remove all process definitions for a specific deployment
List<ProcessDefinition> allDefinitionsForDeployment =
new ProcessDefinitionQueryImpl(Context.getCommandContext())
.deploymentId(deploymentId)
.list();
for (ProcessDefinition processDefinition : allDefinitionsForDeployment) {
try {
removeProcessDefinition(processDefinition.getId());
} catch (Exception e) {
LOGGER.log(
Level.WARNING,
"Could not remove process definition with id '"
+ processDefinition.getId()
+ "' from the cache.",
e);
}
}
}
public Void migrateProcessInstance(CommandContext commandContext, String processInstanceId) {
ExecutionEntity processInstance =
commandContext.getExecutionManager().findExecutionById(processInstanceId);
ProcessDefinitionEntity targetProcessDefinition =
Context.getProcessEngineConfiguration()
.getDeploymentCache()
.findDeployedProcessDefinitionById(migrationPlan.getTargetProcessDefinitionId());
// Initialize migration: match migration instructions to activity instances and collect required
// entities
MigratingProcessInstance migratingProcessInstance =
MigratingProcessInstance.initializeFrom(
commandContext, migrationPlan, processInstance, targetProcessDefinition);
validateInstructions(migratingProcessInstance);
migrateProcessInstance(migratingProcessInstance);
return null;
}
public ProcessDefinitionEntity resolveProcessDefinition(
ProcessDefinitionEntity processDefinition) {
String processDefinitionId = processDefinition.getId();
String deploymentId = processDefinition.getDeploymentId();
processDefinition = processDefinitionCache.get(processDefinitionId);
if (processDefinition == null) {
DeploymentEntity deployment =
Context.getCommandContext().getDeploymentManager().findDeploymentById(deploymentId);
deployment.setNew(false);
deploy(deployment);
processDefinition = processDefinitionCache.get(processDefinitionId);
if (processDefinition == null) {
throw new ProcessEngineException(
"deployment '"
+ deploymentId
+ "' didn't put process definition '"
+ processDefinitionId
+ "' in the cache");
}
}
return processDefinition;
}
protected ActivityImpl getCurrentActivity(CommandContext commandContext, JobEntity job) {
String type = job.getJobHandlerType();
ActivityImpl activity = null;
String configuration = job.getJobHandlerConfiguration();
if (TimerExecuteNestedActivityJobHandler.TYPE.equals(type)
|| TimerCatchIntermediateEventJobHandler.TYPE.equals(type)) {
ExecutionEntity execution = fetchExecutionEntity(job.getExecutionId());
if (execution != null) {
String acitivtyId = TimerEventJobHandler.getKey(configuration);
activity = execution.getProcessDefinition().findActivity(acitivtyId);
}
} else if (TimerStartEventJobHandler.TYPE.equals(type)) {
DeploymentCache deploymentCache =
Context.getProcessEngineConfiguration().getDeploymentCache();
String definitionKey = TimerEventJobHandler.getKey(configuration);
ProcessDefinitionEntity processDefinition =
deploymentCache.findDeployedLatestProcessDefinitionByKey(definitionKey);
if (processDefinition != null) {
activity = processDefinition.getInitial();
}
} else if (AsyncContinuationJobHandler.TYPE.equals(type)) {
ExecutionEntity execution = fetchExecutionEntity(job.getExecutionId());
if (execution != null) {
activity = execution.getActivity();
}
} else {
// noop, because activity type is not supported
}
return activity;
}
public Void execute(final CommandContext commandContext) {
ensureAtLeastOneNotNull(
"At least one of the following correlation criteria has to be present: "
+ "messageName, businessKey, correlationKeys, processInstanceId",
messageName,
builder.getBusinessKey(),
builder.getCorrelationProcessInstanceVariables(),
builder.getProcessInstanceId());
final CorrelationHandler correlationHandler =
Context.getProcessEngineConfiguration().getCorrelationHandler();
final CorrelationSet correlationSet = new CorrelationSet(builder);
List<MessageCorrelationResult> correlationResults =
commandContext.runWithoutAuthorization(
new Callable<List<MessageCorrelationResult>>() {
public List<MessageCorrelationResult> call() throws Exception {
return correlationHandler.correlateMessages(
commandContext, messageName, correlationSet);
}
});
// check authorization
for (MessageCorrelationResult correlationResult : correlationResults) {
checkAuthorization(correlationResult);
}
for (MessageCorrelationResult correlationResult : correlationResults) {
if (MessageCorrelationResult.TYPE_EXECUTION.equals(correlationResult.getResultType())) {
triggerExecution(commandContext, correlationResult);
} else {
instantiateProcess(commandContext, correlationResult);
}
}
return null;
}
public Session openSession() {
return Context.getCommandContext().getDbSqlSession();
}
public void notify(DelegateCaseExecution caseExecution) throws Exception {
Context.getProcessEngineConfiguration()
.getScriptingEnvironment()
.execute(script, caseExecution);
}