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); }