public override void Execute(IActivityExecution execution)
{
if (IsAfterEventBasedGateway)
{
Leave(execution);
}
}
protected internal static void EnsureScope(IActivityExecution execution)
{
if (!execution.IsScope)
{
throw new ProcessEngineException("Execution must be scope.");
}
}
public static void InitFormPropertiesOnScope(IVariableMap variables, IActivityExecution execution)
{
ProcessDefinitionEntity pd = (ProcessDefinitionEntity)((PvmExecutionImpl)execution).ProcessDefinition;
IStartFormHandler startFormHandler = pd.StartFormHandler;
startFormHandler.SubmitFormVariables(variables, execution);
}
protected internal static void EnsureConcurrent(IActivityExecution execution)
{
if (!execution.IsConcurrent)
{
throw new ProcessEngineException("Execution must be concurrent.");
}
}
public void Execute(IActivityExecution execution)
{
var more = execution.Activity.FindOutgoingTransition("more");
var done = execution.Activity.FindOutgoingTransition("done");
var value = (int?)execution.GetVariable(_variableName);
if (value == null)
{
execution.SetVariable(_variableName, _from);
execution.LeaveActivityViaTransition(more);
}
else
{
value = value + 1;
if (value < _to)
{
execution.SetVariable(_variableName, value);
execution.LeaveActivityViaTransition(more);
}
else
{
execution.LeaveActivityViaTransition(done);
}
}
}
/// <summary>
/// Takes an <seealso cref="IActivityExecution" /> and wraps
/// the call to the Callable with the proper error propagation. This method
/// also makes sure that exceptions not caught by following activities in the
/// process will be thrown and not propagated.
/// </summary>
/// <param name="execution"> </param>
/// <param name="toExecute"> </param>
/// <exception cref="exception"> </exception>
protected internal virtual void ExecuteWithErrorPropagation(IActivityExecution execution,
Action toExecute)
{
var activityInstanceId = execution.ActivityInstanceId;
try
{
toExecute.Invoke();
}
catch (System.Exception ex)
{
execution.CreateIncident(IncidentFields.FailedTask, "", ex.ToString().Length > 1500? ex.ToString().Substring(0, 1500): ex.ToString());
if (activityInstanceId == execution.ActivityInstanceId)
{
try
{
PropagateException(execution, ex);
}
catch (ErrorPropagationException e)
{
LOG.ErrorPropagationException(activityInstanceId, e.InnerException);
// re-throw the original exception so that it is logged
// and set as cause of the failure
throw ex;
}
}
else
{
throw ex;
}
}
}
protected internal override void StartInstance(IActivityExecution execution, IVariableMap variables, string businessKey)
{
ProcessDefinitionImpl definition = CallableElementUtil.GetProcessDefinitionToCall(execution, CallableElement);
IPvmProcessInstance processInstance = execution.CreateSubProcessInstance(definition, businessKey);
processInstance.Start(variables);
}
protected internal virtual void HandleChildRemovalInScope(ExecutionEntity removedExecution)
{
// TODO: the following should be closer to PvmAtomicOperationDeleteCascadeFireActivityEnd
// (note though that e.g. boundary events expect concurrent executions to be preserved)
//
// Idea: attempting to prune and synchronize on the parent is the default behavior when
// a concurrent child is removed, but scope activities implementing ModificationObserverBehavior
// override this default (and thereforemust* take care of reorganization themselves)
// notify the behavior that a concurrent execution has been removed
// must be set due to deleteCascade behavior
ActivityImpl activity = removedExecution.Activity as ActivityImpl;
ScopeImpl flowScope = activity.FlowScope;
IActivityExecution scopeExecution = removedExecution.GetParentScopeExecution(false);
IActivityExecution executionInParentScope = removedExecution.IsConcurrent ? removedExecution : removedExecution.Parent;
if (flowScope.ActivityBehavior != null && flowScope.ActivityBehavior is IModificationObserverBehavior)
{
// let child removal be handled by the scope itself
IModificationObserverBehavior behavior = (IModificationObserverBehavior)flowScope.ActivityBehavior;
behavior.DestroyInnerInstance(executionInParentScope);
}
else
{
if (executionInParentScope.IsConcurrent)
{
executionInParentScope.Remove();
scopeExecution.TryPruneLastConcurrentChild();
scopeExecution.ForceUpdate();
}
}
}
protected internal virtual bool ActivatesGateway(IActivityExecution execution, IPvmActivity gatewayActivity)
{
var numExecutionsGuaranteedToActivate = gatewayActivity.IncomingTransitions.Count;
var scopeExecution = execution.IsScope ? execution : execution.Parent;
var executionsAtGateway = execution.FindInactiveConcurrentExecutions(gatewayActivity);
if (executionsAtGateway.Count >= numExecutionsGuaranteedToActivate)
{
return(true);
}
var executionsNotAtGateway = GetLeafExecutions(scopeExecution);
foreach (var it in executionsAtGateway)
{
executionsNotAtGateway.Remove(it);
}
foreach (var executionNotAtGateway in executionsNotAtGateway)
{
if (CanReachActivity(executionNotAtGateway, gatewayActivity))
{
return(false);
}
}
// if no more token may arrive, then activate
return(true);
}
// Activity Behavior
public override void Execute(IActivityExecution execution)
{
var scope = Context.CommandContext.Scope;
var type = ReflectUtil.LoadClass(_className);
object clazz;
if (scope.IsRegistered(type))
{
clazz = scope.Resolve(type);
}
else
{
clazz = ReflectUtil.Instantiate(_className);
}
if (type != null)
{
//execution.SetVariableLocal(_className,clazz);
MethodInfo m = ReflectUtil.GetMethod(type, _methodName);
if (m == null)
{
throw Log.MissingClassException(_className);
}
PerformExecution(execution, m, clazz);
return;
}
throw Log.MissingClassException(_className);
}
// Helpers //////////////////////////////////////////////////////////////////////
protected internal virtual int ResolveNrOfInstances(IActivityExecution execution)
{
var nrOfInstances = -1;
if (loopCardinalityExpression != null)
{
nrOfInstances = ResolveLoopCardinality(execution);
}
else if (collectionExpression != null)
{
var obj = collectionExpression.GetValue(execution);
if (!(obj.GetType().IsAssignableFrom(typeof(ICollection))))
{
throw Log.UnresolvableExpressionException(collectionExpression.ExpressionText, "Collection");
}
nrOfInstances = ((IList)obj)?.Count ?? 0;
}
else if (!ReferenceEquals(collectionVariable, null))
{
var obj = execution.GetVariable(collectionVariable);
if (!(obj.GetType().IsAssignableFrom(typeof(ICollection))))
{
throw Log.InvalidVariableTypeException(collectionVariable, "Collection");
}
nrOfInstances = ((IList)obj)?.Count ?? 0;
}
else
{
throw Log.ResolveCollectionExpressionOrVariableReferenceException();
}
return(nrOfInstances);
}
public override void Execute(IActivityExecution execution)
{
if (IsAfterEventBasedGateway || ConditionalEvent.TryEvaluate(execution))
{
Leave(execution);
}
}
public virtual void execute(IActivityExecution execution)
{
var currentActivity = execution.Activity;
var escalationEventDefinitionFinder = new EscalationEventDefinitionFinder(this, Escalation.EscalationCode,
currentActivity);
var activityExecutionMappingCollector = new ActivityExecutionMappingCollector(execution);
var walker = new ActivityExecutionHierarchyWalker(execution);
walker.AddScopePreVisitor(escalationEventDefinitionFinder);
walker.AddExecutionPreVisitor(activityExecutionMappingCollector);
walker.AddExecutionPreVisitor(new OutputVariablesPropagator());
walker.WalkUntil((element) => escalationEventDefinitionFinder.EscalationEventDefinition != null || element == null);
var escalationEventDefinition = escalationEventDefinitionFinder.EscalationEventDefinition;
if (escalationEventDefinition != null)
{
executeEscalationHandler(escalationEventDefinition, activityExecutionMappingCollector);
}
if ((escalationEventDefinition == null) || !escalationEventDefinition.CancelActivity)
{
LeaveExecution(execution, currentActivity, escalationEventDefinition);
}
}
protected internal virtual IActivityBehavior GetActivityBehaviorInstance(IActivityExecution execution)
{
IExpression expression =
Context.CommandContext.ProcessEngineConfiguration.ExpressionManager.CreateExpression($"{_className}.{_methodName}()");
return(new ServiceTaskExpressionActivityBehavior(expression, _resultVariable));
}
public override void ExecutionStarted(IActivityExecution execution)
{
FormPropertyHelper.InitFormPropertiesOnScope(formProperties, execution);
// make sure create events are fired after form is submitted
base.ExecutionStarted(execution);
}
public override void Signal(IActivityExecution execution, string signalName, object signalData)
{
// join compensating executions
if (!execution.HasChildren())
{
Leave(execution);
}
}
public override void Complete(IActivityExecution scopeExecution)
{
// check whether legacy behavior needs to be performed.
if (!LegacyBehavior.EventSubprocessComplete(scopeExecution))
{
base.Complete(scopeExecution);
}
}
public virtual void ConcurrentChildExecutionEnded(IActivityExecution scopeExecution,
IActivityExecution endedExecution)
{
// join
endedExecution.Remove();
scopeExecution.TryPruneLastConcurrentChild();
scopeExecution.ForceUpdate();
}
protected internal virtual IActivityExecution FindFirstLeaf(IActivityExecution execution)
{
if (execution.HasChildren())
{
return(FindFirstLeaf(execution.Executions[0]));
}
return(execution);
}
/// <summary>
/// event-scope executions are not considered in this mapping and must be ignored
/// </summary>
protected internal virtual bool IsLeaf(IActivityExecution execution)
{
if (CompensationBehavior.IsCompensationThrowing((PvmExecutionImpl)execution))
{
return(true);
}
return(!execution.IsEventScope && execution.NonEventScopeExecutions.Count == 0);
}
public ActivityBehaviorSignalInvocation(ISignallableActivityBehavior behaviorInstance,
IActivityExecution execution, string signalName, object signalData) : base(execution, null)
{
this._behaviorInstance = behaviorInstance;
this._execution = execution;
this._signalName = signalName;
this._signalData = signalData;
}
protected internal override void StartInstance(IActivityExecution execution, IVariableMap variables,
string businessKey)
{
throw new NotImplementedException();
//CmmnCaseDefinition definition = getCaseDefinitionToCall(execution, CallableElement);
//CmmnCaseInstance caseInstance = execution.createSubCaseInstance(definition, businessKey);
//caseInstance.create(variables);
}
public override void DestroyInnerInstance(IActivityExecution scopeExecution)
{
RemoveLoopVariable(scopeExecution, LoopCounter);
var nrOfActiveInstances = GetLoopVariable(scopeExecution, NumberOfActiveInstances);
SetLoopVariable(scopeExecution, NumberOfActiveInstances, nrOfActiveInstances - 1);
}
public TreeVisitorAnonymousInnerClass(IActivityExecution execution,
IDictionary <ScopeImpl, PvmExecutionImpl> scopeExecutionMapping,
ISet <EventSubscriptionEntity> subscriptions)
{
this._execution = execution;
this._scopeExecutionMapping = scopeExecutionMapping;
this._subscriptions = subscriptions;
}
public override void Execute(IActivityExecution execution)
{
var executionEntity = (ExecutionEntity)execution;
var provider = context.Impl.Context.ProcessEngineConfiguration.ExternalTaskPriorityProvider;
var priority = provider.DeterminePriority(executionEntity, this, null);
ExternalTaskEntity.CreateAndInsert(executionEntity, TopicName, priority);
}
public override void Execute(IActivityExecution execution)
{
IPvmActivity initialActivity = execution.Activity.Properties.Get(BpmnProperties.InitialActivity);
EnsureUtil.EnsureNotNull("No initial activity found for subprocess " + execution.Activity.Id,
"initialActivity", initialActivity);
execution.ExecuteActivity(initialActivity);
}
public override void Execute(IActivityExecution execution)
{
ExecuteWithErrorPropagation(execution, () =>
{
DecisionEvaluationUtil.EvaluateDecision((AbstractVariableScope)execution, CallableElement,
ResultVariable, DecisionResultMapper);
Leave(execution);
});
}
public override void DoLeave(IActivityExecution execution)
{
// continue via the appropriate cancel boundary event
var eventScope = (ScopeImpl)cancelBoundaryEvent.EventScope;
var boundaryEventScopeExecution = execution.FindExecutionForFlowScope(eventScope);
boundaryEventScopeExecution.ExecuteActivity(cancelBoundaryEvent);
}
protected internal virtual void PerformInstance(IActivityExecution execution, IPvmActivity activity,
int loopCounter)
{
SetLoopVariable(execution, LoopCounter, loopCounter);
EvaluateCollectionVariable(execution, loopCounter);
execution.IsEnded = false;
execution.IsActive = true;
execution.ExecuteActivity(activity);
}
protected internal virtual int GetLoopVariable(IActivityExecution execution, string variableName)
{
IIntegerValue value = execution.GetVariableLocalTyped <IIntegerValue>(variableName);
EnsureUtil.EnsureNotNull(
"The variable \"" + variableName + "\" could not be found in execution with id " + execution.Id, "value",
value);
return((int)value.Value);
}
