public void CanPersistAndRestore() { IWorkflowEntity toReturn = new WorkflowEntity(); _workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Return(toReturn); _workflowPersister.Expect(p => p.Save(new WorkflowEntity())).IgnoreArguments().Callback <IWorkflowEntity>(x => { toReturn = x; return(true); }); IStateMachineContext machineContext = _workflowService.Start(@"testStateMachine.boo"); Assert.IsNotNull(machineContext); Assert.IsTrue(machineContext.IsStarted); Assert.IsNotNull(toReturn); Assert.That(Guid.Empty == toReturn.WorkflowId, Is.Not.True); Assert.AreEqual("Initial", machineContext.CurrentState.StateName); Assert.AreNotEqual(Guid.Empty, machineContext.Id); _workflowPersister.Expect(p => p.Load(new Guid())).IgnoreArguments().Return(toReturn); IStateMachineContext restoredMachine = _workflowService.Load(machineContext.Id); Assert.AreNotSame(restoredMachine, _workflowService); Assert.IsTrue(restoredMachine.IsStarted); Assert.AreEqual(machineContext.CurrentState.StateName, restoredMachine.CurrentState.StateName); _workflowPersister.VerifyAllExpectations(); }
public void CanCreateSaveUpdateAndComplete() { IWorkflowEntity toReturn = new WorkflowEntity(); _workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Repeat.Times(1).Return(toReturn); _workflowPersister.Expect(p => p.Load(Guid.Empty)).IgnoreArguments().Repeat.Times(2).Return(toReturn); _workflowPersister.Expect(p => p.Save(toReturn)); _workflowPersister.Expect(p => p.Update(toReturn)); _workflowPersister.Expect(p => p.Complete(toReturn)); IStateMachineContext machineContext = _workflowService.Start(@"simplestatemachine.boo"); Assert.IsNotNull(machineContext); Assert.IsTrue(machineContext.IsStarted); Assert.AreEqual("Initial", machineContext.CurrentState.StateName); // should trigger the Update machineContext.HandleEvent(1); Assert.AreEqual("First", machineContext.CurrentState.StateName); // should trigger the Complete machineContext.HandleEvent(3); _workflowPersister.VerifyAllExpectations(); }
public static List <IStateMachineEventAction> GetMatchingEventActions(this IStateMachineContext context, object eventIdentifier) { var actions = new List <IStateMachineEventAction>(); if (context == null || context.StateMachine == null) { return(actions); } if (context.StateMachine.EventActions != null) { foreach (IStateMachineEventAction action in context.StateMachine.EventActions) { if (action.Matches(context, eventIdentifier)) { actions.Add(action); } } } if (context.CurrentState != null && context.CurrentState.EventActions != null) { foreach (IStateMachineEventAction action in context.CurrentState.EventActions) { if (action.Matches(context, eventIdentifier)) { actions.Add(action); } } } return(actions); }
public static IStateMachineContext UseLazyHandlerArgs(this IStateMachineContext context, Func <IPipeContext, object[]> argsFunc) { Func <IPipeContext, Func <IPipeContext, object[]> > lazyFunc = pipeContext => argsFunc; context.Properties.TryAdd(StateMachineKey.LazyHandlerArgsFunc, lazyFunc); return(context); }
public static List <IStateTransitionAction> GetMatchingTransitionActions(this IStateMachineContext context, StateTransitionPhase transitionPhase) { var actions = new List <IStateTransitionAction>(); if (context == null || context.StateMachine == null) { return(actions); } if (context.StateMachine.StateTransitionActions != null) { foreach (IStateTransitionAction action in context.StateMachine.StateTransitionActions) { if (action.Matches(context, transitionPhase)) { actions.Add(action); } } } if (context.CurrentState != null && context.CurrentState.StateTransitionActions != null) { foreach (IStateTransitionAction action in context.CurrentState.StateTransitionActions) { if (action.Matches(context, transitionPhase)) { actions.Add(action); } } } return(actions); }
public static IStateTransition FindFirstMatchingTransition(this IStateMachineContext context, IStateMachineEvent transitionEvent) { if (context == null || context.CurrentState == null) { return(null); } if (transitionEvent == null) { throw new ArgumentNullException("transitionEvent"); } if (context.CurrentState.Transitions == null) { return(null); } foreach (IStateTransition transition in context.CurrentState.Transitions) { if (transition.Matches(transitionEvent, context)) { return(transition); } } return(null); }
public static List <IStateTransition> FindMatchingTransitions(this IStateMachineContext context) { if (context == null || context.CurrentState == null) { throw new ArgumentNullException("context"); } if (context.CurrentState.Transitions == null) { return(null); } List <IStateTransition> transitions = new List <IStateTransition>(); foreach (IStateTransition transition in context.CurrentState.Transitions) { if (transition.Matches("NA", context)) { transitions.Add(transition); } } if (transitions.Count > 0) { return(transitions); } else { return(null); } }
public StateBehaviourBuilder(IState <TState, TInput> source, IStateDictionary <TState, TInput> states, IStateMachineContext <TState, TInput> context) { _source = source; _states = states; _context = context; _transitions = new List <TransitionInfo>(); }
private void BindToWorkflow(IStateMachineContext workflow) { _currentWorkflow = workflow; if (_currentWorkflow != null) { availableActionPanel1.Workflow = _currentWorkflow; _currentWorkflow.StateInitialized += _currentWorkflow_StateInitialized; } }
public StateMachine(string name, IStateMachineContext <TState, TInput> context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } Name = name; this.context = context; states = new StateDictionary <TState, TInput>(this.context); }
public void LateUpdate(float deltaTime, StateMachine stateMachine, IStateMachineContext context) { if (!_contextType.IsAssignableFrom(context.GetType())) { // Log Or throw exception return; } LateUpdate(deltaTime, stateMachine, (TContext)context); }
public void Exit(IStateMachineContext context) { if (!_contextType.IsAssignableFrom(context.GetType())) { // Log Or throw exception return; } Exit((TContext)context); }
public void HandleStateTransition(IStateMachineContext <IState <Transitions>, Transitions> stateContext, Transitions transition) { if (transition == Transitions.Play) { stateContext.State = new Playing(); } else { throw new InvalidStateTransitionException(transition); } }
private void UnBindFromWorkflow() { if (_currentWorkflow == null) { return; } availableActionPanel1.Workflow = null; _currentWorkflow.StateInitialized -= _currentWorkflow_StateInitialized; _currentWorkflow = null; }
private void BindToWorkflow(IStateMachineContext workflow) { _workflow = workflow; if (_workflow != null) { _workflow.StateMachineStarted += _workflow_StateMachineStarted; _workflow.StateMachineComplete += _workflow_StateMachineComplete; _workflow.StateInitialized += _workflow_StateInitialized; RefreshButtonAvailability(); } }
public void CanCreateUsingWorkflowServiceTest() { IWorkflowEntity toReturn = new WorkflowEntity(); _workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Return(toReturn); IStateMachineContext machineContext = _workflowService.Start(@"testStateMachine.boo"); Assert.IsNotNull(machineContext); Assert.IsTrue(machineContext.IsStarted); _workflowPersister.VerifyAllExpectations(); }
public void ChangeState(object sender, IState nextState, IStateMachineContext context) { if (!context.IsActive && sender != null) { return; } if (sender == context.CurrentState) { ChangeState(nextState, context); } }
/// <summary> /// Calls in LateUpdate loop /// </summary> /// <param name="deltaTime"><see cref="Time.deltaTime"/></param> public void LateUpdate(float deltaTime, IStateMachineContext context) { if (!context.IsActive) { return; } if (context.CurrentState != null) { context.CurrentState.LateUpdate(deltaTime, this, context); } }
public override async Task<StateResult> OnEntry(IStateMachineContext<IExecutionContext> context) { try { Interruptable = false; await DeActivateWorker(context.ExecutionContext); context.ExecutionContext.IsMaster = false; await ContactNeighbours(context.ExecutionContext); PostObit(context); } finally { Interruptable = true; } return FinalResult; }
private void UnBindFromWorkflow() { if (_workflow != null) { _workflow.StateMachineStarted -= _workflow_StateMachineStarted; _workflow.StateMachineComplete -= _workflow_StateMachineComplete; _workflow.StateInitialized -= _workflow_StateInitialized; _workflow = null; _pnlButtonContainer.Controls.Clear(); } }
protected virtual void CoreExitImpl(IStateMachineContext <TState, TInput> context) { foreach (var exitAction in exitActions) { try { exitAction.Execute(context); } catch (Exception e) { context.HandleException(e); } } }
/// <summary> /// Gets the domain context. /// </summary> /// <param name="workFlow">The work flow.</param> /// <returns></returns> private static object GetDomainContext(IStateMachineContext workFlow) { object domainContext; if (workFlow.DomainContext is ReflectiveDomainContextWrapper) { domainContext = ((ReflectiveDomainContextWrapper)workFlow.DomainContext).DomainContext; } else { domainContext = workFlow.DomainContext; } return(domainContext); }
public void CanPersistAndRestoreDomainContextWithStatusProperty() { var user = new User(); user.StatusChanged += user_StatusChanged; _domainContextRepository.Expect(x => x.GetId(user)).Return(user.Id); _domainContextRepository.Expect(x => x.GetTypeDescription(user)).Return("SimpleStateMachine.User"); _domainContextRepository.Expect(x => x.Save(user)); _domainContextRepository.Expect(x => x.Load("SimpleStateMachine.User", user.Id)).Return(new User()); IWorkflowEntity toReturn = new WorkflowEntity(); _workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Return(toReturn); _workflowPersister.Expect(p => p.Save(new WorkflowEntity())).IgnoreArguments().Callback <IWorkflowEntity>(x => { toReturn = x; return(true); }); IStateMachineContext machineContext = _workflowService.Start(@"testStateMachine.boo", user, "CurrentStatus"); Assert.IsNotNull(machineContext); Assert.IsTrue(machineContext.IsStarted); Assert.AreEqual(user.CurrentStatus, machineContext.CurrentState.StateIdentifier); Assert.AreEqual(1, _userStateChangedCount); _workflowPersister.Expect(p => p.Load(new Guid())).IgnoreArguments().Return(toReturn); IStateMachineContext restoredMachine = _workflowService.Load(machineContext.Id); Assert.IsAssignableFrom(typeof(ReflectiveDomainContextWrapper), restoredMachine.DomainContext); var contextWrapper = (ReflectiveDomainContextWrapper)restoredMachine.DomainContext; Assert.IsAssignableFrom(typeof(User), contextWrapper.DomainContext); // should be the newly loaded user. Assert.AreNotEqual(contextWrapper.DomainContext, user); Assert.AreNotEqual(((User)contextWrapper.DomainContext).Id, user.Id); // state changed should not have been called! // is it up to the domain context repository to restore the state of the domain context. Assert.AreEqual(1, _userStateChangedCount); _domainContextRepository.VerifyAllExpectations(); _workflowPersister.VerifyAllExpectations(); }
public void HandleStateTransition(IStateMachineContext <IState <Transitions>, Transitions> stateContext, Transitions transition) { if (transition == Transitions.Pause) { stateContext.State = new Paused(); } else if (transition == Transitions.Stop) { stateContext.State = new Stopped(); } else { throw new InvalidStateTransitionException(transition); } }
private void ChangeState(IState newState, IStateMachineContext context) { if (context.DebugStateMachine) { Debug.Log(context.GO.name + " " + context.GetType().Name + " " + newState.GetType().Name); } if (context.CurrentState != null) { context.CurrentState.Exit(context); } context.CurrentState = newState; if (context.CurrentState != null) { context.CurrentState.Enter(context); } }
public UpdateHandler( ILifetimeScope lifetimeScope, IUpdateContext updateContext, IStateMachineConfigurationProvider configurationProvider, IStateMachineContext stateMachineContext, IIdentityStatesService identityStatesService, IEnumerable <IUpdateInterceptor> updateInterceptors, ILogger <UpdateHandler> logger) { _lifetimeScope = lifetimeScope; _updateContext = updateContext; _configurationProvider = configurationProvider; _stateMachineContext = stateMachineContext; _identityStatesService = identityStatesService; _updateInterceptors = updateInterceptors; _logger = logger; }
public virtual bool Matches(object eventId, IStateMachineContext context) { if (TriggerEvent != null) { if (TriggerEvent.Matches(eventId) || (eventId is string && (eventId.ToString().Equals("NA")))) { if (this.RolesRequired != null && this.RolesRequired.Count > 0) { foreach (string role in this.RolesRequired) { AFEContext afe = new AFEContext(); afe.Assignments = new List <AFEAssignment>(); afe.UserID = 1; afe.Assignments.Add(new AFEAssignment() { AfeRoleCode = "AAPR", Order = 1, UserID = 1 }); afe.Assignments.Add(new AFEAssignment() { AfeRoleCode = "AAPR", Order = 2, UserID = 2 }); bool IsLastUserInTheCurrentOrder = afe.IsLastUserInTheCurrentOrder(role); bool IsLastPersonInTheCurrentRole = afe.IsLastPersonInTheCurrentRole(role); if (afe.Assignments.FindAll(t => t.AfeRoleCode == role && t.UserID == afe.UserID).Count > 0) { return(true); } else { return(false); } } } else { return(true); } } } return(false); }
public static void SetState(this IStateMachineContext context, object stateIdentifier) { if (context == null) { throw new ArgumentNullException("context"); } if (stateIdentifier == null) { throw new ArgumentNullException("stateIdentifier"); } IStateMachineState target = FindState(context.StateMachine, stateIdentifier); if (target != null) { context.SetState(target); } }
public void CanPersistAndRestoreDomainContext() { var user = new User(); user.StatusChanged += user_StatusChanged; _domainContextRepository.Expect(x => x.GetId(user)).Return(user.Id); _domainContextRepository.Expect(x => x.GetTypeDescription(user)).Return("SimpleStateMachine.User"); _domainContextRepository.Expect(x => x.Save(user)); _domainContextRepository.Expect(x => x.Load("SimpleStateMachine.User", user.Id)).Return(new User()); IWorkflowEntity toReturn = new WorkflowEntity(); _workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Return(toReturn); _workflowPersister.Expect(p => p.Save(new WorkflowEntity())).IgnoreArguments().Callback <IWorkflowEntity>(x => { toReturn = x; return(true); }); IStateMachineContext machineContext = _workflowService.Start(@"testStateMachine.boo", user); Assert.IsNotNull(machineContext); Assert.IsTrue(machineContext.IsStarted); _workflowPersister.Expect(p => p.Load(new Guid())).IgnoreArguments().Return(toReturn); IStateMachineContext restoredMachine = _workflowService.Load(machineContext.Id); Assert.IsAssignableFrom(typeof(User), restoredMachine.DomainContext); // should be the newly loaded user. Assert.AreNotEqual(restoredMachine.DomainContext, user); Assert.AreNotEqual(((User)restoredMachine.DomainContext).Id, user.Id); // should have never been called Assert.AreEqual(0, _userStateChangedCount); _domainContextRepository.VerifyAllExpectations(); _workflowPersister.VerifyAllExpectations(); }
public static Neighbour Fabricate(IStateMachineContext<IExecutionContext> context) { var cfg = new Configuration().WithAppropriateOverrides(); var nexus = cfg.Get(Constants.Configuration.Nexus); var strength = cfg.Get(Constants.Configuration.MachineStrength); var actualStrength = string.IsNullOrEmpty(strength) ? MachineStrength.Compute : (MachineStrength)Enum.Parse(typeof(MachineStrength), strength, true); return new Neighbour { IsMaster = context.ExecutionContext.IsMaster, Name = context.ExecutionContext.HostName, UpTime = context.EnclosingMachine.UpTime, AbsoluteBootTime = context.EnclosingMachine.AbsoluteBootTime, Strength = actualStrength.ToString(), // Could be null if not yet interrogated Hardware = HardwareDetails.Instance ?? new HardwareDetails(), InEligibleForElection = context.ExecutionContext.InEligibleForElection, PendingEvents = context.EnclosingMachine.PendingEvents.Select(e => new PendingEvent { Id = e.Id, Name = e.EventName, CreatedOn = e.CreatedOn, AgeInSeconds = (DateTime.Now - e.CreatedOn).TotalSeconds }).ToArray(), HandledEvents = context.EnclosingMachine.StatisticsHandler.HandledEventsInNameOrder.ToArray(), WorkUnitsExecuted = context.ExecutionContext.WorkerExecutionUnits, NodeId = context.ExecutionContext.NodeId, SupposedNeighbours = string.IsNullOrEmpty(nexus) ? Enumerable.Empty<string>().ToArray() : nexus.Split(','), CurrentState = context.EnclosingMachine.CurrentState.IsNull() ? "None" : context.EnclosingMachine.CurrentState.Name }; }
public void IdOfContextMatchesIdOfLoadedMachineTest() { IWorkflowEntity toReturn = new WorkflowEntity(); _workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Return(toReturn); _workflowPersister.Expect(p => p.Save(new WorkflowEntity())).IgnoreArguments().Callback <IWorkflowEntity>(x => { toReturn = x; return(true); }); IStateMachineContext machineContext = _workflowService.Start(@"testStateMachine.boo"); Assert.IsNotNull(machineContext); Assert.IsTrue(machineContext.IsStarted); _workflowPersister.Expect(p => p.Load(new Guid())).IgnoreArguments().Return(toReturn); IStateMachineContext restoredMachine = _workflowService.Load(machineContext.Id); Assert.AreEqual(restoredMachine.Id, machineContext.Id); }
public override Task<StateResult> OnEntry(IStateMachineContext<IExecutionContext> context) { context.ExecutionContext.IsMaster = true; EnsureWorkerActive(context.ExecutionContext); return Task.FromResult(StateResult.None); }
public static Neighbour CreateNeighbour(IStateMachineContext<IExecutionContext> ctx, Action<Neighbour> f = null) { Neighbour n = Neighbour.Fabricate(ctx); if (f != null) f(n); return n; }
protected override void PostObit(IStateMachineContext<IExecutionContext> context) { //ChannelPrototype.Respond(context.CurrentEvent.ResponseContainer, "Accepted", Configuration.Get<int>(Constants.Configuration.ResponseLimit)); context.ExecutionContext.InEligibleForElection = true; LogFacade.Instance.LogInfo("Marking self as IN-eligible for election"); }
protected virtual void PostObit(IStateMachineContext<IExecutionContext> context) { }
public override async Task<StateResult> OnEntry(IStateMachineContext<IExecutionContext> context) { await DeActivateWorker(context.ExecutionContext); context.ExecutionContext.IsMaster = false; return StateResult.None; }
public abstract void Setup(IStateMachineContext _context);