public WalkConditionAnonymousInnerClass2(AbstractInstantiationCmd outerInstance, ProcessDefinitionImpl processDefinition, ActivityExecutionTreeMapping mapping, ExecutionEntity ancestorScopeExecution, PvmScope ancestorScope) { this.outerInstance = outerInstance; this.processDefinition = processDefinition; this.mapping = mapping; this.ancestorScopeExecution = ancestorScopeExecution; this.ancestorScope = ancestorScope; }
protected internal virtual void executeEscalationHandler(EscalationEventDefinition escalationEventDefinition, ActivityExecutionMappingCollector activityExecutionMappingCollector) { PvmActivity escalationHandler = escalationEventDefinition.EscalationHandler; PvmScope escalationScope = getScopeForEscalation(escalationEventDefinition); ActivityExecution escalationExecution = activityExecutionMappingCollector.getExecutionForScope(escalationScope); if (!string.ReferenceEquals(escalationEventDefinition.EscalationCodeVariable, null)) { escalationExecution.setVariable(escalationEventDefinition.EscalationCodeVariable, escalation.EscalationCode); } escalationExecution.executeActivity(escalationHandler); }
/// <summary> /// This method </summary> /// <param name="scopeExecution"> /// @return </param> protected internal static bool isLegacyBehaviorRequired(ActivityExecution scopeExecution) { // legacy behavior is turned off: the current activity was parsed as scope. // now we need to check whether a scope execution was correctly created for the // event subprocess. // first create the mapping: IDictionary <ScopeImpl, PvmExecutionImpl> activityExecutionMapping = scopeExecution.createActivityExecutionMapping(); // if the scope execution for the current activity is the same as for the parent scope // -> we need to perform legacy behavior PvmScope activity = scopeExecution.Activity; if (!activity.Scope) { activity = activity.FlowScope; } return(activityExecutionMapping[activity] == activityExecutionMapping[activity.FlowScope]); }
protected internal override ActivityExecutionTuple nextElement() { ActivityExecutionTuple currentElement = CurrentElement; PvmScope currentScope = currentElement.Scope; PvmExecutionImpl currentExecution = (PvmExecutionImpl)currentElement.Execution; PvmScope flowScope = currentScope.FlowScope; if (!currentExecution.Scope) { currentExecution = activityExecutionMapping[currentScope]; return(new ActivityExecutionTuple(currentScope, currentExecution)); } else if (flowScope != null) { // walk to parent scope PvmExecutionImpl execution = activityExecutionMapping[flowScope]; return(new ActivityExecutionTuple(flowScope, execution)); } else { // this is the process instance, look for parent currentExecution = activityExecutionMapping[currentScope]; PvmExecutionImpl superExecution = currentExecution.SuperExecution; if (superExecution != null) { // walk to parent process instance activityExecutionMapping = superExecution.createActivityExecutionMapping(); return(createTupel(superExecution)); } else { // this is the top level process instance return(null); } } }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: public Void execute(final org.camunda.bpm.engine.impl.interceptor.CommandContext commandContext) public override Void execute(CommandContext commandContext) { ExecutionEntity processInstance = commandContext.ExecutionManager.findExecutionById(processInstanceId); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.camunda.bpm.engine.impl.pvm.process.ProcessDefinitionImpl processDefinition = processInstance.getProcessDefinition(); ProcessDefinitionImpl processDefinition = processInstance.getProcessDefinition(); CoreModelElement elementToInstantiate = getTargetElement(processDefinition); EnsureUtil.ensureNotNull(typeof(NotValidException), describeFailure("Element '" + TargetElementId + "' does not exist in process '" + processDefinition.Id + "'"), "element", elementToInstantiate); // rebuild the mapping because the execution tree changes with every iteration //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.camunda.bpm.engine.impl.ActivityExecutionTreeMapping mapping = new org.camunda.bpm.engine.impl.ActivityExecutionTreeMapping(commandContext, processInstanceId); ActivityExecutionTreeMapping mapping = new ActivityExecutionTreeMapping(commandContext, processInstanceId); // before instantiating an activity, two things have to be determined: // // activityStack: // For the activity to instantiate, we build a stack of parent flow scopes // for which no executions exist yet and that have to be instantiated // // scopeExecution: // This is typically the execution under which a new sub tree has to be created. // if an explicit ancestor activity instance is set: // - this is the scope execution for that ancestor activity instance // - throws exception if that scope execution is not in the parent hierarchy // of the activity to be started // if no explicit ancestor activity instance is set: // - this is the execution of the first parent/ancestor flow scope that has an execution // - throws an exception if there is more than one such execution ScopeImpl targetFlowScope = getTargetFlowScope(processDefinition); // prepare to walk up the flow scope hierarchy and collect the flow scope activities ActivityStackCollector stackCollector = new ActivityStackCollector(); FlowScopeWalker walker = new FlowScopeWalker(targetFlowScope); walker.addPreVisitor(stackCollector); ExecutionEntity scopeExecution = null; // if no explicit ancestor activity instance is set if (string.ReferenceEquals(ancestorActivityInstanceId, null)) { // walk until a scope is reached for which executions exist walker.walkWhile(new WalkConditionAnonymousInnerClass(this, processDefinition, mapping)); ISet <ExecutionEntity> flowScopeExecutions = mapping.getExecutions(walker.CurrentElement); if (flowScopeExecutions.Count > 1) { throw new ProcessEngineException("Ancestor activity execution is ambiguous for activity " + targetFlowScope); } scopeExecution = flowScopeExecutions.GetEnumerator().next(); } else { ActivityInstance tree = commandContext.runWithoutAuthorization(new CallableAnonymousInnerClass(this, commandContext)); ActivityInstance ancestorInstance = findActivityInstance(tree, ancestorActivityInstanceId); EnsureUtil.ensureNotNull(typeof(NotValidException), describeFailure("Ancestor activity instance '" + ancestorActivityInstanceId + "' does not exist"), "ancestorInstance", ancestorInstance); // determine ancestor activity scope execution and activity //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity ancestorScopeExecution = getScopeExecutionForActivityInstance(processInstance, mapping, ancestorInstance); ExecutionEntity ancestorScopeExecution = getScopeExecutionForActivityInstance(processInstance, mapping, ancestorInstance); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.camunda.bpm.engine.impl.pvm.PvmScope ancestorScope = getScopeForActivityInstance(processDefinition, ancestorInstance); PvmScope ancestorScope = getScopeForActivityInstance(processDefinition, ancestorInstance); // walk until the scope of the ancestor scope execution is reached walker.walkWhile(new WalkConditionAnonymousInnerClass2(this, processDefinition, mapping, ancestorScopeExecution, ancestorScope)); ISet <ExecutionEntity> flowScopeExecutions = mapping.getExecutions(walker.CurrentElement); if (!flowScopeExecutions.Contains(ancestorScopeExecution)) { throw new NotValidException(describeFailure("Scope execution for '" + ancestorActivityInstanceId + "' cannot be found in parent hierarchy of flow element '" + elementToInstantiate.Id + "'")); } scopeExecution = ancestorScopeExecution; } IList <PvmActivity> activitiesToInstantiate = stackCollector.ActivityStack; activitiesToInstantiate.Reverse(); // We have to make a distinction between // - "regular" activities for which the activity stack can be instantiated and started // right away // - interrupting or cancelling activities for which we have to ensure that // the interruption and cancellation takes place before we instantiate the activity stack ActivityImpl topMostActivity = null; ScopeImpl flowScope = null; if (activitiesToInstantiate.Count > 0) { topMostActivity = (ActivityImpl)activitiesToInstantiate[0]; flowScope = topMostActivity.FlowScope; } else if (elementToInstantiate.GetType().IsAssignableFrom(typeof(ActivityImpl))) { topMostActivity = (ActivityImpl)elementToInstantiate; flowScope = topMostActivity.FlowScope; } else if (elementToInstantiate.GetType().IsAssignableFrom(typeof(TransitionImpl))) { TransitionImpl transitionToInstantiate = (TransitionImpl)elementToInstantiate; flowScope = transitionToInstantiate.Source.FlowScope; } if (!supportsConcurrentChildInstantiation(flowScope)) { throw new ProcessEngineException("Concurrent instantiation not possible for " + "activities in scope " + flowScope.Id); } ActivityStartBehavior startBehavior = ActivityStartBehavior.CONCURRENT_IN_FLOW_SCOPE; if (topMostActivity != null) { startBehavior = topMostActivity.ActivityStartBehavior; if (activitiesToInstantiate.Count > 0) { // this is in BPMN relevant if there is an interrupting event sub process. // we have to distinguish between instantiation of the start event and any other activity. // instantiation of the start event means interrupting behavior; instantiation // of any other task means no interruption. PvmActivity initialActivity = topMostActivity.Properties.get(BpmnProperties.INITIAL_ACTIVITY); PvmActivity secondTopMostActivity = null; if (activitiesToInstantiate.Count > 1) { secondTopMostActivity = activitiesToInstantiate[1]; } else if (elementToInstantiate.GetType().IsAssignableFrom(typeof(ActivityImpl))) { secondTopMostActivity = (PvmActivity)elementToInstantiate; } if (initialActivity != secondTopMostActivity) { startBehavior = ActivityStartBehavior.CONCURRENT_IN_FLOW_SCOPE; } } } switch (startBehavior) { case ActivityStartBehavior.CANCEL_EVENT_SCOPE: { ScopeImpl scopeToCancel = topMostActivity.EventScope; ExecutionEntity executionToCancel = getSingleExecutionForScope(mapping, scopeToCancel); if (executionToCancel != null) { executionToCancel.deleteCascade("Cancelling activity " + topMostActivity + " executed.", skipCustomListeners, skipIoMappings); instantiate(executionToCancel.Parent, activitiesToInstantiate, elementToInstantiate); } else { ExecutionEntity flowScopeExecution = getSingleExecutionForScope(mapping, topMostActivity.FlowScope); instantiateConcurrent(flowScopeExecution, activitiesToInstantiate, elementToInstantiate); } break; } case ActivityStartBehavior.INTERRUPT_EVENT_SCOPE: { ScopeImpl scopeToCancel = topMostActivity.EventScope; ExecutionEntity executionToCancel = getSingleExecutionForScope(mapping, scopeToCancel); executionToCancel.interrupt("Interrupting activity " + topMostActivity + " executed.", skipCustomListeners, skipIoMappings); executionToCancel.setActivity(null); executionToCancel.leaveActivityInstance(); instantiate(executionToCancel, activitiesToInstantiate, elementToInstantiate); break; } case ActivityStartBehavior.INTERRUPT_FLOW_SCOPE: { ScopeImpl scopeToCancel = topMostActivity.FlowScope; ExecutionEntity executionToCancel = getSingleExecutionForScope(mapping, scopeToCancel); executionToCancel.interrupt("Interrupting activity " + topMostActivity + " executed.", skipCustomListeners, skipIoMappings); executionToCancel.setActivity(null); executionToCancel.leaveActivityInstance(); instantiate(executionToCancel, activitiesToInstantiate, elementToInstantiate); break; } default: { // if all child executions have been cancelled // or this execution has ended executing its scope, it can be reused if (!scopeExecution.hasChildren() && (scopeExecution.getActivity() == null || scopeExecution.Ended)) { // reuse the scope execution instantiate(scopeExecution, activitiesToInstantiate, elementToInstantiate); } else { // if the activity is not cancelling/interrupting, it can simply be instantiated as // a concurrent child of the scopeExecution instantiateConcurrent(scopeExecution, activitiesToInstantiate, elementToInstantiate); } break; } } return(null); }
protected internal static ActivityExecutionTuple createTupel(ActivityExecution execution) { PvmScope flowScope = getCurrentFlowScope(execution); return(new ActivityExecutionTuple(flowScope, execution)); }
public static IDictionary <string, EventSubscriptionDeclaration> getDeclarationsForScope(PvmScope scope) { if (scope == null) { return(Collections.emptyMap()); } return(scope.Properties.get(BpmnProperties.EVENT_SUBSCRIPTION_DECLARATIONS)); }
/// <returns> the mapped execution for scope or <code>null</code>, if no mapping exists </returns> public virtual PvmExecutionImpl getExecutionForScope(PvmScope scope) { return(activityExecutionMapping[scope]); }
public virtual void execute(PvmExecutionImpl execution) { // restore activity instance id if (string.ReferenceEquals(execution.ActivityInstanceId, null)) { execution.ActivityInstanceId = execution.ParentActivityInstanceId; } PvmActivity activity = execution.getActivity(); IDictionary <ScopeImpl, PvmExecutionImpl> activityExecutionMapping = execution.createActivityExecutionMapping(); PvmExecutionImpl propagatingExecution = execution; if (execution.Scope && activity.Scope) { if (!LegacyBehavior.destroySecondNonScope(execution)) { execution.destroy(); if (!execution.Concurrent) { execution.remove(); propagatingExecution = execution.Parent; propagatingExecution.setActivity(execution.getActivity()); } } } propagatingExecution = LegacyBehavior.determinePropagatingExecutionOnEnd(propagatingExecution, activityExecutionMapping); PvmScope flowScope = activity.FlowScope; // 1. flow scope = Process Definition if (flowScope == activity.ProcessDefinition) { // 1.1 concurrent execution => end + tryPrune() if (propagatingExecution.Concurrent) { propagatingExecution.remove(); propagatingExecution.Parent.tryPruneLastConcurrentChild(); propagatingExecution.Parent.forceUpdate(); } else { // 1.2 Process End propagatingExecution.Ended = true; if (!propagatingExecution.PreserveScope) { propagatingExecution.performOperation(PvmAtomicOperation_Fields.PROCESS_END); } } } else { // 2. flowScope != process definition PvmActivity flowScopeActivity = (PvmActivity)flowScope; ActivityBehavior activityBehavior = flowScopeActivity.ActivityBehavior; if (activityBehavior is CompositeActivityBehavior) { CompositeActivityBehavior compositeActivityBehavior = (CompositeActivityBehavior)activityBehavior; // 2.1 Concurrent execution => composite behavior.concurrentExecutionEnded() if (propagatingExecution.Concurrent && !LegacyBehavior.isConcurrentScope(propagatingExecution)) { compositeActivityBehavior.concurrentChildExecutionEnded(propagatingExecution.Parent, propagatingExecution); } else { // 2.2 Scope Execution => composite behavior.complete() propagatingExecution.setActivity(flowScopeActivity); compositeActivityBehavior.complete(propagatingExecution); } } else { // activity behavior is not composite => this is unexpected throw new ProcessEngineException("Expected behavior of composite scope " + activity + " to be a CompositeActivityBehavior but got " + activityBehavior); } } }
public static IDictionary <string, TimerDeclarationImpl> getDeclarationsForScope(PvmScope scope) { if (scope == null) { return(Collections.emptyMap()); } IDictionary <string, TimerDeclarationImpl> result = scope.Properties.get(BpmnProperties.TIMER_DECLARATIONS); if (result != null) { return(result); } else { return(Collections.emptyMap()); } }