コード例 #1
0
        /// <summary>
        /// Returns a list of flow scopes from the given scope until a scope is reached that is already present in the given
        /// <seealso cref="MigratingScopeInstanceBranch"/> (exclusive). The order of the returned list is top-down, i.e. the highest scope
        /// is the first element of the list.
        /// </summary>
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: protected java.util.List<org.camunda.bpm.engine.impl.pvm.process.ScopeImpl> collectNonExistingFlowScopes(org.camunda.bpm.engine.impl.pvm.process.ScopeImpl scope, final MigratingScopeInstanceBranch migratingExecutionBranch)
        protected internal virtual IList <ScopeImpl> collectNonExistingFlowScopes(ScopeImpl scope, MigratingScopeInstanceBranch migratingExecutionBranch)
        {
            FlowScopeWalker walker = new FlowScopeWalker(scope);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<org.camunda.bpm.engine.impl.pvm.process.ScopeImpl> result = new java.util.LinkedList<org.camunda.bpm.engine.impl.pvm.process.ScopeImpl>();
            IList <ScopeImpl> result = new LinkedList <ScopeImpl>();

            walker.addPreVisitor(new TreeVisitorAnonymousInnerClass(this, result));

            walker.walkWhile(new WalkConditionAnonymousInnerClass(this, migratingExecutionBranch));

            return(result);
        }
コード例 #2
0
//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);
        }