Exemple #1
0
        protected internal override void instantiateScopes(MigratingScopeInstance ancestorScopeInstance, MigratingScopeInstanceBranch executionBranch, IList <ScopeImpl> scopesToInstantiate)
        {
            if (scopesToInstantiate.Count == 0)
            {
                return;
            }

            ExecutionEntity ancestorScopeExecution = ancestorScopeInstance.resolveRepresentativeExecution();

            ExecutionEntity parentExecution = ancestorScopeExecution;

            foreach (ScopeImpl scope in scopesToInstantiate)
            {
                ExecutionEntity compensationScopeExecution = parentExecution.createExecution();
                compensationScopeExecution.Scope      = true;
                compensationScopeExecution.EventScope = true;

                compensationScopeExecution.setActivity((PvmActivity)scope);
                compensationScopeExecution.Active = false;
                compensationScopeExecution.activityInstanceStarting();
                compensationScopeExecution.enterActivityInstance();

                EventSubscriptionEntity eventSubscription = EventSubscriptionEntity.createAndInsert(parentExecution, EventType.COMPENSATE, (ActivityImpl)scope);
                eventSubscription.Configuration = compensationScopeExecution.Id;

                executionBranch.visited(new MigratingEventScopeInstance(eventSubscription, compensationScopeExecution, scope));

                parentExecution = compensationScopeExecution;
            }
        }
Exemple #2
0
        public virtual void attachState(MigratingScopeInstance owningInstance)
        {
            ExecutionEntity representativeExecution = owningInstance.resolveRepresentativeExecution();

            representativeExecution.addExternalTask(externalTask);

            externalTask.Execution = representativeExecution;
        }
Exemple #3
0
        public override void attachState(MigratingScopeInstance targetActivityInstance)
        {
            Parent = targetActivityInstance;

            ExecutionEntity representativeExecution = targetActivityInstance.resolveRepresentativeExecution();

            eventSubscription.Execution = representativeExecution;
        }
Exemple #4
0
 public override void remove(bool skipCustomListeners, bool skipIoMappings)
 {
     // never invokes listeners and io mappings because this does not remove an active
     // activity instance
     eventScopeExecution.remove();
     migratingEventSubscription.remove();
     Parent = null;
 }
Exemple #5
0
        public virtual void attachState(MigratingScopeInstance newOwningInstance)
        {
            attachTo(newOwningInstance.resolveRepresentativeExecution());

            foreach (MigratingInstance dependentInstance in migratingDependentInstances)
            {
                dependentInstance.attachState(newOwningInstance);
            }
        }
Exemple #6
0
        public virtual void visited(MigratingScopeInstance scopeInstance)
        {
            ScopeImpl targetScope = scopeInstance.TargetScope;

            if (targetScope.Scope)
            {
                scopeInstances[targetScope] = scopeInstance;
            }
        }
Exemple #7
0
        public override void attachState(MigratingScopeInstance activityInstance)
        {
            this.setParent(activityInstance);
            instanceBehavior.attachState();

            foreach (MigratingInstance dependentInstance in migratingDependentInstances)
            {
                dependentInstance.attachState(this);
            }
        }
Exemple #8
0
 public override void addChild(MigratingScopeInstance migratingScopeInstance)
 {
     if (migratingScopeInstance is MigratingEventScopeInstance)
     {
         childInstances.Add((MigratingEventScopeInstance)migratingScopeInstance);
     }
     else
     {
         throw MIGRATION_LOGGER.cannotHandleChild(this, migratingScopeInstance);
     }
 }
Exemple #9
0
        public virtual void attachState(MigratingScopeInstance owningInstance)
        {
            ExecutionEntity representativeExecution = owningInstance.resolveRepresentativeExecution();

            representativeExecution.addTask(userTask);

            foreach (VariableInstanceEntity variable in userTask.VariablesInternal)
            {
                variable.Execution = representativeExecution;
            }

            userTask.setExecution(representativeExecution);
        }
Exemple #10
0
        public override void setParent(MigratingScopeInstance parentInstance)
        {
            if (this.parentInstance != null)
            {
                this.parentInstance.removeChild(this);
            }

            this.parentInstance = parentInstance;

            if (parentInstance != null)
            {
                parentInstance.addChild(this);
            }
        }
Exemple #11
0
        public virtual void attachState(MigratingScopeInstance owningActivityInstance)
        {
            ExecutionEntity representativeExecution = owningActivityInstance.resolveRepresentativeExecution();
            ScopeImpl       currentScope            = owningActivityInstance.CurrentScope;

            ExecutionEntity newOwningExecution = representativeExecution;

            if (currentScope.Scope && isConcurrentLocalInParentScope)
            {
                newOwningExecution = representativeExecution.Parent;
            }

            newOwningExecution.addVariableInternal(variable);
        }
Exemple #12
0
 public override void removeChild(MigratingScopeInstance child)
 {
     if (child is MigratingActivityInstance)
     {
         removeChild((MigratingActivityInstance)child);
     }
     else if (child is MigratingEventScopeInstance)
     {
         removeChild((MigratingEventScopeInstance)child);
     }
     else
     {
         throw MIGRATION_LOGGER.cannotHandleChild(this, child);
     }
 }
Exemple #13
0
        protected internal virtual void migrateProcessElementInstance(MigratingProcessElementInstance migratingInstance, MigratingScopeInstanceBranch migratingInstanceBranch)
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final MigratingScopeInstance parentMigratingInstance = migratingInstance.getParent();
            MigratingScopeInstance parentMigratingInstance = migratingInstance.Parent;

            ScopeImpl sourceScope     = migratingInstance.SourceScope;
            ScopeImpl targetScope     = migratingInstance.TargetScope;
            ScopeImpl targetFlowScope = targetScope.FlowScope;
            ScopeImpl parentActivityInstanceTargetScope = parentMigratingInstance != null ? parentMigratingInstance.TargetScope : null;

            if (sourceScope != sourceScope.ProcessDefinition && targetFlowScope != parentActivityInstanceTargetScope)
            {
                // create intermediate scopes

                // 1. manipulate execution tree

                // determine the list of ancestor scopes (parent, grandparent, etc.) for which
                //     no executions exist yet
                IList <ScopeImpl> nonExistingScopes = collectNonExistingFlowScopes(targetFlowScope, migratingInstanceBranch);

                // get the closest ancestor scope that is instantiated already
                ScopeImpl existingScope = nonExistingScopes.Count == 0 ? targetFlowScope : nonExistingScopes[0].FlowScope;

                // and its scope instance
                MigratingScopeInstance ancestorScopeInstance = migratingInstanceBranch.getInstance(existingScope);

                // Instantiate the scopes as children of the scope execution
                instantiateScopes(ancestorScopeInstance, migratingInstanceBranch, nonExistingScopes);

                MigratingScopeInstance targetFlowScopeInstance = migratingInstanceBranch.getInstance(targetFlowScope);

                // 2. detach instance
                // The order of steps 1 and 2 avoids intermediate execution tree compaction
                // which in turn could overwrite some dependent instances (e.g. variables)
                migratingInstance.detachState();

                // 3. attach to newly created activity instance
                migratingInstance.attachState(targetFlowScopeInstance);
            }

            // 4. update state (e.g. activity id)
            migratingInstance.migrateState();

            // 5. migrate instance state other than execution-tree structure
            migratingInstance.migrateDependentEntities();
        }
Exemple #14
0
        protected internal override ICollection <MigrationContext> nextElements()
        {
            ICollection <MigrationContext> nextElements = new LinkedList <MigrationContext>();

            MigrationContext currentElement = CurrentElement;

            // continue migration for non-leaf instances (i.e. scopes)
            if (currentElement.processElementInstance is MigratingScopeInstance)
            {
                // Child instances share the same scope instance branch;
                // This ensures "once-per-parent" instantiation semantics,
                // i.e. if a new parent scope is added to more than one child, all those children
                // will share the same new parent instance.
                // By changing the way how the branches are created here, it should be possible
                // to implement other strategies, e.g. "once-per-child" semantics
                MigratingScopeInstanceBranch childrenScopeBranch             = currentElement.scopeInstanceBranch.copy();
                MigratingScopeInstanceBranch childrenCompensationScopeBranch = currentElement.scopeInstanceBranch.copy();

                MigratingScopeInstance scopeInstance = (MigratingScopeInstance)currentElement.processElementInstance;

                childrenScopeBranch.visited(scopeInstance);
                childrenCompensationScopeBranch.visited(scopeInstance);

                foreach (MigratingProcessElementInstance child in scopeInstance.Children)
                {
                    MigratingScopeInstanceBranch instanceBranch = null;

                    // compensation and non-compensation scopes cannot share the same scope instance branch
                    // e.g. when adding a sub process, we want to create a new activity instance as well
                    // as a new event scope instance for that sub process
                    if (child is MigratingEventScopeInstance || child is MigratingCompensationEventSubscriptionInstance)
                    {
                        instanceBranch = childrenCompensationScopeBranch;
                    }
                    else
                    {
                        instanceBranch = childrenScopeBranch;
                    }
                    nextElements.Add(new MigrationContext(child, instanceBranch));
                }
            }

            return(nextElements);
        }
Exemple #15
0
        public override void setParent(MigratingScopeInstance parentInstance)
        {
            if (parentInstance != null && !(parentInstance is MigratingActivityInstance))
            {
                throw MIGRATION_LOGGER.cannotHandleChild(parentInstance, this);
            }

            MigratingActivityInstance parentActivityInstance = (MigratingActivityInstance)parentInstance;

            if (this.parentInstance != null)
            {
                ((MigratingActivityInstance)this.parentInstance).removeChild(this);
            }

            this.parentInstance = parentActivityInstance;

            if (parentInstance != null)
            {
                parentActivityInstance.addChild(this);
            }
        }
Exemple #16
0
        public override void attachState(MigratingScopeInstance scopeInstance)
        {
            if (!(scopeInstance is MigratingActivityInstance))
            {
                throw MIGRATION_LOGGER.cannotHandleChild(scopeInstance, this);
            }

            MigratingActivityInstance activityInstance = (MigratingActivityInstance)scopeInstance;

            setParent(activityInstance);

            representativeExecution = activityInstance.createAttachableExecution();
            representativeExecution.ActivityInstanceId = null;
            representativeExecution.Active             = activeState;

            jobInstance.attachState(this);

            foreach (MigratingInstance dependentInstance in migratingDependentInstances)
            {
                dependentInstance.attachState(this);
            }
        }
Exemple #17
0
        protected internal override void instantiateScopes(MigratingScopeInstance ancestorScopeInstance, MigratingScopeInstanceBranch executionBranch, IList <ScopeImpl> scopesToInstantiate)
        {
            if (scopesToInstantiate.Count == 0)
            {
                return;
            }

            // must always be an activity instance
            MigratingActivityInstance ancestorActivityInstance = (MigratingActivityInstance)ancestorScopeInstance;

            ExecutionEntity newParentExecution = ancestorActivityInstance.createAttachableExecution();

            IDictionary <PvmActivity, PvmExecutionImpl> createdExecutions = newParentExecution.instantiateScopes((System.Collections.IList)scopesToInstantiate, skipCustomListeners, skipIoMappings);

            foreach (ScopeImpl scope in scopesToInstantiate)
            {
                ExecutionEntity createdExecution = (ExecutionEntity)createdExecutions[scope];
                createdExecution.setActivity(null);
                createdExecution.Active = false;
                executionBranch.visited(new MigratingActivityInstance(scope, createdExecution));
            }
        }
Exemple #18
0
 public abstract void addChild(MigratingScopeInstance migratingActivityInstance);
Exemple #19
0
 public override void removeChild(MigratingScopeInstance migratingScopeInstance)
 {
     childInstances.remove(migratingScopeInstance);
 }
Exemple #20
0
 protected internal abstract void instantiateScopes(MigratingScopeInstance ancestorScopeInstance, MigratingScopeInstanceBranch executionBranch, IList <ScopeImpl> scopesToInstantiate);
Exemple #21
0
 public virtual void attachState(MigratingScopeInstance newOwningInstance)
 {
     attachTo(newOwningInstance.resolveRepresentativeExecution());
 }
Exemple #22
0
 public virtual void attachState(MigratingScopeInstance newOwningInstance)
 {
     eventSubscriptionEntity.Execution = newOwningInstance.resolveRepresentativeExecution();
 }
Exemple #23
0
 public virtual void attachState(MigratingScopeInstance targetActivityInstance)
 {
     processInstance.setSuperExecution(targetActivityInstance.resolveRepresentativeExecution());
 }
Exemple #24
0
 public abstract void attachState(MigratingScopeInstance targetActivityInstance);