Пример #1
0
        public SecurableClassDefinition CreateAndCommitSecurableClassDefinitionWithAccessControlLists(int accessControlLists, ClientTransaction transaction)
        {
            CreateEmptyDomain();

            using (transaction.EnterNonDiscardingScope())
            {
                SecurableClassDefinition   classDefinition            = CreateOrderSecurableClassDefinition();
                StatelessAccessControlList statelessAccessControlList = StatelessAccessControlList.NewObject();
                classDefinition.StatelessAccessControlList = statelessAccessControlList;

                var stateProperty = StatePropertyDefinition.NewObject(Guid.NewGuid(), "Property");
                classDefinition.AddStateProperty(stateProperty);

                for (int i = 1; i < accessControlLists; i++)
                {
                    StatefulAccessControlList statefulAccessControlList = StatefulAccessControlList.NewObject();
                    classDefinition.StatefulAccessControlLists.Add(statefulAccessControlList);
                    statefulAccessControlList.CreateAccessControlEntry();
                    CreateStateCombination(statefulAccessControlList, stateProperty, StateDefinition.NewObject(string.Format("Value {0}", i), i));
                }

                ClientTransactionScope.CurrentTransaction.Commit();

                return(classDefinition);
            }
        }
Пример #2
0
    public void StateDefinitionTestSimplePasses()
    {
        DummyClass dc   = new DummyClass();
        DummyClass copy = new DummyClass();

        dc.i           = 1;
        dc.f           = 2f;
        dc.d           = 3d;
        dc.l           = 4L;
        dc.v           = new Vector3(1, 2, 3);
        dc.q           = Quaternion.Euler(30f, 45f, 15f);
        dc.notRecorded = 1;

        StateDefinition sd = StateDefinitionFactory.CreateDefinition(typeof(DummyClass), "i", "f");

        byte[] bytes = sd.GetState(dc);
        Debug.Log("State of data container: " + System.BitConverter.ToString(bytes));

        sd.SetState(copy, bytes);
        Assert.AreEqual(dc.i, copy.i);
        Assert.AreEqual(dc.f, copy.f);
        Assert.AreEqual(dc.d, copy.d);
        Assert.AreEqual(dc.l, copy.l);
        Assert.AreNotEqual(dc.notRecorded, copy.notRecorded);
    }
Пример #3
0
        /// <summary>
        /// Create a new LogDownloader
        /// </summary>
        /// <param name="isAsyncTransfer">Determines if this machine will be set up asyncronus transfers.</param>
        /// <param name="threadName">The name to report in closing operations for this binary socket.</param>
        /// <param name="closingWorker">The closing worker to add this binary socket too.</param>
        protected ThreadedTransferMachine(bool isAsyncTransfer, string threadName, ClosingWorker closingWorker) : base(threadName)
        {
            // add thread to the closing worker
            closingWorker?.AddThread(this);

            // initialize the StateMachine
            WorkerState = new StateDefinition();

            if (isAsyncTransfer)
            {
                MachineFunctions.InitializeStates(WorkerStateMachine = new StepDefinition(threadName, true, WorkerState)
                {
                    #region StateMachine
                    SubSteps = new List <StepDefinition>
                    {
                        new StepDefinition("Transfer Packet")
                        {
                            Delegate = StateMachine_TransferPacket, DelayTimeMs = 500
                        },
                        new StepDefinition("Packet Timeout")
                        {
                            Delegate = StateMachine_PacketTimeout, DelayTimeMs = 0
                        },
                        new StepDefinition("Complete")
                        {
                            Delegate = StateMachine_Complete, DelayTimeMs = 200
                        }
                    }
                    #endregion // StateMachine
                });
            }
            else
            {
                MachineFunctions.InitializeStates(WorkerStateMachine = new StepDefinition(threadName, true, WorkerState)
                {
                    #region StateMachine
                    SubSteps = new List <StepDefinition>
                    {
                        new StepDefinition("Transfer Packet")
                        {
                            Delegate = StateMachine_TransferPacket, DelayTimeMs = 0
                        },
                        new StepDefinition("Complete")
                        {
                            Delegate = StateMachine_Complete, DelayTimeMs = 200
                        }
                    }
                    #endregion // StateMachine
                });
            }

            // start the StateMachine in the Complete state
            MachineFunctions.JumpToLast(WorkerStateMachine);

            // initialize ThreadingBase
            WorkerThreads = new List <ThreadInfo>
            {
                new ThreadInfo(new Thread(Worker), "State Machine", threadName, WorkerStateMachine)
            };
        }
    void ImportMecanimLayer(StateDefinition def, AC ac, int layer)
    {
        string name = "MecanimLayer_" + layer + "_Weight";

        PropertyDefinition pdef = def.Properties.FirstOrDefault(x => x.StateAssetSettings.MecanimLayer == layer && x.StateAssetSettings.MecanimMode == MecanimMode.LayerWeight);

        if (pdef == null)
        {
            pdef = CreateProperty(new PropertyStateSettings());
            pdef.PropertyType = new PropertyTypeFloat()
            {
                Compression = new FloatCompression {
                    Accuracy = 0.01f, MinValue = 0, MaxValue = 1, Enabled = true
                }
            };
            pdef.Name = name;
            pdef.StateAssetSettings.MecanimLayer     = layer;
            pdef.StateAssetSettings.MecanimMode      = MecanimMode.LayerWeight;
            pdef.StateAssetSettings.MecanimDirection = MecanimDirection.UsingAnimatorMethods;

            Debug.Log(string.Format("Imported Mecanim Layer: {0}", pdef.Name));

            def.Properties.Add(pdef);
        }
        else if (!(pdef.PropertyType is PropertyTypeFloat))
        {
            pdef.PropertyType = new PropertyTypeFloat()
            {
                Compression = new FloatCompression {
                    Accuracy = 0.01f, MinValue = 0, MaxValue = 1, Enabled = true
                }
            };
            Debug.Log(string.Format("Updated Mecanim Layer: {0}", pdef.Name));
        }
    }
Пример #5
0
        /// <inheritdoc/>
        public virtual IWorkflowBuilder EndsWith(Func <IStateBuilderFactory, IStateBuilder> stateSetup)
        {
            StateDefinition state = this.AddState(stateSetup);

            state.End = new EndDefinition();
            return(this.Workflow);
        }
        /// <summary>
        /// Registers the given object.
        /// Returns true if it was registered, false if it was already registered.
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        public bool Register(object o)
        {
            if (o == null)
            {
                throw new ArgumentException("Object given is null.");
            }

            if (!registeredObjects.ContainsKey(o))
            {
                // Create a definition for this type, if it doesn't exist.
                if (!definitions.ContainsKey(o.GetType()))
                {
                    StateDefinition sd = StateDefinitionFactory.CreateDefinition(o.GetType());
                    definitions.Add(o.GetType(), sd);
                }

                registeredObjects.Add(o, new RecordableMetadata(nextObjID, TimeState.NOMINAL));
                nextObjID++;
                //print("Registered object " + o.ToString() + ". Hashcode: " + o.GetHashCode());
                return(true);
            }
            else
            {
                print("Dictionary contains key " + o + ": " + registeredObjects.ContainsKey(o));
            }
            return(false);
        }
Пример #7
0
 /// <inheritdoc/>
 public virtual IWorkflowExecutionTimeoutBuilder Run(StateDefinition state)
 {
     if (state == null)
     {
         throw new ArgumentNullException(nameof(state));
     }
     return(this.Run(this.Pipeline.AddState(state).Name));
 }
Пример #8
0
        public void AttachState(StateDefinition state)
        {
            ArgumentUtility.CheckNotNull("state", state);
            StateUsage stateUsage = StateUsage.NewObject();

            stateUsage.StateDefinition = state;
            StateUsages.Add(stateUsage);
        }
Пример #9
0
 public static void GetName(StateDefinition obj, MethodReturnEventArgs <string> e)
 {
     e.Result = obj.Module != null?
                string.Format("Workflow.StateDefinitions.{0}.{1}.{2}",
                              obj.WFDefinition.Module.Namespace,
                              Regex.Replace(obj.WFDefinition.Name, "\\W", "_"),
                              Regex.Replace(obj.Name, "\\W", "_")) : null;
 }
Пример #10
0
        private StateDefinition CreateState(string name, int value)
        {
            StateDefinition state = StateDefinition.NewObject(name, value);

            state.Index = value;

            return(state);
        }
Пример #11
0
 public StateBuilder(
     TState stateId,
     IImplicitAddIfNotAvailableStateDefinitionDictionary <TState, TEvent> stateDefinitionDictionary,
     IFactory <TState, TEvent> factory)
 {
     this.stateDefinitionDictionary = stateDefinitionDictionary;
     this.factory         = factory;
     this.stateDefinition = this.stateDefinitionDictionary[stateId];
 }
Пример #12
0
 /// <inheritdoc/>
 public virtual IPipelineBuilder Then(Func <IStateBuilderFactory, IStateBuilder> stateSetup)
 {
     if (stateSetup == null)
     {
         throw new ArgumentNullException(nameof(stateSetup));
     }
     this.CurrentState = this.AddState(stateSetup);
     return(this);
 }
Пример #13
0
 /// <inheritdoc/>
 public virtual StateDefinition AddState(StateDefinition state)
 {
     if (state == null)
     {
         throw new ArgumentNullException(nameof(state));
     }
     this.States.Add(state);
     return(state);
 }
        public HierarchyBuilderTest()
        {
            this.superState = new StateDefinition <string, int>(SuperState);
            this.states     = A.Fake <IImplicitAddIfNotAvailableStateDefinitionDictionary <string, int> >();
            A.CallTo(() => this.states[SuperState]).Returns(this.superState);
            this.initiallyLastActiveStates = A.Fake <IDictionary <string, string> >();

            this.testee = new HierarchyBuilder <string, int>(SuperState, this.states, this.initiallyLastActiveStates);
        }
Пример #15
0
        // We remember the parents for States separately from the State object itself
        // to make it easier to deal with deserialized states (which lack the parent structure)

        /// <summary>
        /// Add a new state definition
        /// </summary>
        public static State AddState(string name,
                                     Func <TStateMachine, TEvent, State, TContext, Task>?entryAction = null,
                                     Func <TStateMachine, State, TEvent, TContext, Task>?exitAction  = null,
                                     State?parent = null)
        {
            var stateDefinition = new StateDefinition(name, entryAction, exitAction, parent);

            definitions.Add(name, stateDefinition);
            return(stateDefinition.GetState());
        }
Пример #16
0
 /// <inheritdoc/>
 public virtual IStateBuilder <TState> CompensateWith(StateDefinition state)
 {
     if (state == null)
     {
         throw new ArgumentNullException(nameof(state));
     }
     state.UsedForCompensation = true;
     this.State.CompensatedBy  = this.Pipeline.AddState(state).Name;
     return(this);
 }
Пример #17
0
 /// <summary>
 /// Add a state, mapped to a type, to this reference definition.
 /// </summary>
 /// <param name="type">Type of state to add</param>
 /// <param name="def">State definition to add.</param>
 public void AddState(StateType type, StateDefinition def)
 {
     // Enforce only 1 of each type, except for Generic, which can have as many as it wants.
     if (m_StatesPresent.Contains(type) && type != StateType.Generic)
     {
         return;
     }
     m_StatesPresent.Add(type);
     m_StateDefinition.Add(def);
 }
Пример #18
0
        public void GetState_ValidValue()
        {
            StatePropertyDefinition stateProperty = _testHelper.CreateConfidentialityProperty(0);

            StateDefinition actualState = stateProperty.GetState(MetadataTestHelper.Confidentiality_PrivateValue);

            StateDefinition expectedState = _testHelper.CreatePrivateState();

            MetadataObjectAssert.AreEqual(expectedState, actualState, "Private state");
        }
Пример #19
0
        public void Indexer_ValidName()
        {
            StatePropertyDefinition stateProperty = _testHelper.CreateConfidentialityProperty(0);

            StateDefinition actualState = stateProperty[MetadataTestHelper.Confidentiality_ConfidentialName];

            StateDefinition expectedState = _testHelper.CreateConfidentialState();

            MetadataObjectAssert.AreEqual(expectedState, actualState, "Confidential state");
        }
Пример #20
0
        public StateDefinition CreateState(string name, int value)
        {
            using (_transaction.EnterNonDiscardingScope())
            {
                StateDefinition state = StateDefinition.NewObject(name, value);
                state.Index = value;

                return(state);
            }
        }
Пример #21
0
        /// <inheritdoc/>
        public virtual void TransitionTo(Func <IStateBuilderFactory, IStateBuilder> stateSetup)
        {
            //TODO: configure transition
            StateDefinition state = this.Pipeline.AddState(stateSetup);

            this.Outcome = new TransitionDefinition()
            {
                NextState = state.Name
            };
        }
Пример #22
0
 /// <inheritdoc/>
 public virtual IPipelineBuilder StartsWith(StateDefinition state)
 {
     if (state == null)
     {
         throw new ArgumentNullException(nameof(state));
     }
     this.Pipeline.AddState(state);
     this.Workflow.StartStateName = state.Name;
     return(this.Pipeline);
 }
Пример #23
0
        /// <inheritdoc/>
        public virtual IPipelineBuilder StartsWith(Func <IStateBuilderFactory, IStateBuilder> stateSetup)
        {
            if (stateSetup == null)
            {
                throw new ArgumentNullException(nameof(stateSetup));
            }
            StateDefinition state = this.Pipeline.AddState(stateSetup);

            this.Workflow.StartStateName = state.Name;
            return(this.Pipeline);
        }
 /// <summary>
 /// Adds a definition for a type, defining which properties will be recorded.
 /// </summary>
 /// <param name="s"></param>
 public void AddDefinition(StateDefinition s)
 {
     if (!definitions.ContainsKey(s.Type))
     {
         definitions.Add(s.Type, s);
     }
     else
     {
         throw new InvalidOperationException("Cannot add new definition for type '" + s.Type + "', as it already exists.");
     }
 }
Пример #25
0
        public HierarchyBuilder(
            TState superStateId,
            IImplicitAddIfNotAvailableStateDefinitionDictionary <TState, TEvent> stateDefinitions,
            IDictionary <TState, IStateDefinition <TState, TEvent> > initiallyLastActiveStates)
        {
            Guard.AgainstNullArgument("states", stateDefinitions);

            this.stateDefinitions          = stateDefinitions;
            this.initiallyLastActiveStates = initiallyLastActiveStates;
            this.superState = this.stateDefinitions[superStateId];
        }
Пример #26
0
        public void StateEngineTest()
        {
            {
                var orderState = new StateDefinition<Order, OrderState>(
                    x => x.State,
                    new StateTransitionDefinition<Order, OrderState>(OrderState.Init, OrderState.Confirmed),
                    new StateTransitionDefinition<Order, OrderState>(OrderState.Confirmed, OrderState.Processing),
                    new StateTransitionDefinition<Order, OrderState>(OrderState.Processing, OrderState.Done)
                        {
                            Expect = (entity, o) => entity.Delivery.State == DeliveryState.Done
                        }
                    );

                var deliveryState = new StateDefinition<Delivery, DeliveryState>(
                    x => x.State,
                    new StateTransitionDefinition<Delivery, DeliveryState>(DeliveryState.Init, DeliveryState.Prepare)
                        {
                            Expect = (entity, o) => entity.Order.State == OrderState.Processing
                        },
                    new StateTransitionDefinition<Delivery, DeliveryState>(DeliveryState.Prepare, DeliveryState.Sent)
                        {
                            Expect = (entity, o) => entity.Order.State == OrderState.Processing
                        },
                    new StateTransitionDefinition<Delivery, DeliveryState>(DeliveryState.Sent, DeliveryState.Done)
                        {
                            PostAction = (container, entity, arg3) => container.StateEngine.Execute(entity.Order, OrderState.Done)
                        }
                    );

                StateEngine.Add(orderState);
                StateEngine.Add(deliveryState);
            }

            {
                var order = new Order();
                var delivery = new Delivery {Order = order};
                order.Delivery = delivery;

                using (var uow = new DummyUnitOfWorkContainer())
                {
                    Assert.Throws<StateTransitionNotAllowedException>(() => uow.StateEngine.Execute(delivery, DeliveryState.Prepare));
                    uow.StateEngine.Execute(order, OrderState.Confirmed);
                    Assert.Throws<StateTransitionNotAllowedException>(() => uow.StateEngine.Execute(delivery, DeliveryState.Prepare));
                    uow.StateEngine.Execute(order, OrderState.Processing);
                    Assert.Throws<StateTransitionNotAllowedException>(() => uow.StateEngine.Execute(order, OrderState.Done));
                    uow.StateEngine.Execute(delivery, DeliveryState.Prepare);
                    Assert.Throws<StateTransitionNotAllowedException>(() => uow.StateEngine.Execute(order, OrderState.Done));
                    uow.StateEngine.Execute(delivery, DeliveryState.Sent);
                    Assert.Throws<StateTransitionNotAllowedException>(() => uow.StateEngine.Execute(order, OrderState.Done));
                    uow.StateEngine.Execute(delivery, DeliveryState.Done);
                    Assert.Equal(OrderState.Done, order.State);
                }
            }
        }
Пример #27
0
        public void HierarchyWhenDefiningAStateAsItsOwnInitialSubStateThenAnExceptionIsThrown()
        {
            var testee = new StateDefinition <States, Events>(States.A);

            Action action = () => testee.InitialStateModifiable = testee;

            action
            .Should()
            .Throw <ArgumentException>()
            .WithMessage(StatesExceptionMessages.StateCannotBeTheInitialSubStateToItself(testee.ToString()));
        }
Пример #28
0
        private void CheckThatStateHasNotAlreadyASuperState(StateDefinition <TState, TEvent> subState)
        {
            Guard.AgainstNullArgument("subState", subState);

            if (subState.SuperState != null)
            {
                throw new InvalidOperationException(
                          ExceptionMessages.CannotSetStateAsASuperStateBecauseASuperStateIsAlreadySet(
                              this.superState.Id,
                              subState));
            }
        }
Пример #29
0
        public void GetStates_OneState()
        {
            SecurableClassDefinition classDefinition = _testHelper.CreateOrderClassDefinition();
            StatePropertyDefinition  property        = _testHelper.CreatePaymentStateProperty(classDefinition);
            StateDefinition          state           = property.DefinedStates[1];
            StateCombination         combination     = _testHelper.CreateStateCombination(classDefinition, state);

            StateDefinition[] states = combination.GetStates();

            Assert.That(states.Length, Is.EqualTo(1));
            Assert.That(states[0], Is.SameAs(state));
        }
Пример #30
0
        /// <inheritdoc/>
        public virtual IStateBuilder <TState> CompensateWith(Func <IStateBuilderFactory, IStateBuilder> stateSetup)
        {
            if (stateSetup == null)
            {
                throw new ArgumentNullException(nameof(stateSetup));
            }
            StateDefinition compensatedBy = this.Pipeline.AddState(stateSetup);

            compensatedBy.UsedForCompensation = true;
            this.State.CompensatedBy          = compensatedBy.Name;
            return(this);
        }
Пример #31
0
        /// <inheritdoc/>
        public virtual IPipelineBuilder Then(Func <IStateBuilderFactory, IStateBuilder> stateSetup)
        {
            if (stateSetup == null)
            {
                throw new ArgumentNullException(nameof(stateSetup));
            }
            var nextState = this.AddState(stateSetup);

            this.CurrentState.TransitionToStateName = nextState.Name;
            this.CurrentState = nextState;
            return(this);
        }
Пример #32
0
        public void StateEngineTest()
        {
            var stateDefinition = new StateDefinition<TestEntity, TestStatus>(
                x => x.Status,
                new StateTransitionDefinition<TestEntity, TestStatus>(TestStatus.Status1, TestStatus.Status2),
                new StateTransitionDefinition<TestEntity, TestStatus>(TestStatus.Status2, TestStatus.Status3)
                    {
                        ExpectParameterType = typeof (StateChangeArgument),
                        Expect = (entity, o) => entity.Allow,
                        PreAction = (container, entity, arg) =>
                                        {
                                            /* do something before action */
                                        },
                        PostAction = (container, entity, arg) =>
                                     	{
                                     		entity.Date = arg.Date;
                                     		//container.OnCommitAction(() =>
                                     		//                            {
                                     		//                                // Code to send
                                     		//                            });
                                     		container.StateEngine.Execute(entity, TestStatus.Status4);
                                     	}
                    },
                new StateTransitionDefinition<TestEntity, TestStatus>(TestStatus.Status3, TestStatus.Status4),
                new StateTransitionDefinition<TestEntity, TestStatus>(TestStatus.Status4, TestStatus.Status5),
                new StateTransitionDefinition<TestEntity, TestStatus>(TestStatus.Status4, TestStatus.Status6));

            var testEntity = new TestEntity();
            var stateChangeArgument = new StateChangeArgument {Date = DateTime.Now.AddDays(1)};

            using (var uow = new DummyUnitOfWorkContainer())
            {
                Assert.Equal(TestStatus.Status1, testEntity.Status);

                // state is not added and should throw state not found
                Assert.Throws<StateNotFoundForEntityException>(() => uow.StateEngine.Execute(testEntity, TestStatus.Status2));
            }

            // Add state definition to the static collection
            StateEngine.Add(stateDefinition);

            using (var uow = new DummyUnitOfWorkContainer())
            {
                Assert.Equal(TestStatus.Status1, testEntity.Status);

                var allowedStates = uow.StateEngine.GetAvailableTransitions<TestEntity, TestStatus>(testEntity);
                Assert.Equal(new HashSet<TestStatus>(new[] {TestStatus.Status2}), allowedStates);

                Assert.Throws<StateTransitionArgumentException>(() => uow.StateEngine.Execute(testEntity, TestStatus.Status2, stateChangeArgument));
                Assert.Equal(TestStatus.Status1, testEntity.Status);

                uow.StateEngine.Execute(testEntity, TestStatus.Status2);
                Assert.Equal(TestStatus.Status2, testEntity.Status);

                allowedStates = uow.StateEngine.GetAvailableTransitions<TestEntity, TestStatus>(testEntity);
                Assert.Equal(new HashSet<TestStatus>(new[] {TestStatus.Status3}), allowedStates);

                Assert.Throws<StateTransitionArgumentException>(() => uow.StateEngine.Execute(testEntity, TestStatus.Status3));
                Assert.Throws<StateTransitionNotAllowedException>(() => uow.StateEngine.Execute(testEntity, TestStatus.Status3, stateChangeArgument));
                Assert.Equal(TestStatus.Status2, testEntity.Status);

                testEntity.Allow = true;
                Assert.Throws<StateTransitionArgumentException>(() => uow.StateEngine.Execute(testEntity, TestStatus.Status3));
                Assert.Equal(TestStatus.Status2, testEntity.Status);

                uow.StateEngine.Execute(testEntity, TestStatus.Status3, stateChangeArgument);
                Assert.Equal(stateChangeArgument.Date, testEntity.Date);
                // Post action move status one more step so the status should be Status4
                Assert.Equal(TestStatus.Status4, testEntity.Status);

                allowedStates = uow.StateEngine.GetAvailableTransitions<TestEntity, TestStatus>(testEntity);
                Assert.Equal(new HashSet<TestStatus>(new[] {TestStatus.Status5, TestStatus.Status6}), allowedStates);

                Assert.Throws<StateTransitionNotAllowedException>(() => uow.StateEngine.Execute(testEntity, TestStatus.Status1));
                Assert.Throws<StateTransitionNotAllowedException>(() => uow.StateEngine.Execute(testEntity, TestStatus.Status2));
            }
        }