private async Task AdvanceActionWithState(IDeviceStateAction oldState)
{
IDeviceStateAction newState = stateActionController.GetNextAction(oldState);
if (savedStackState.Count > 0)
{
newState.SetState(savedStackState.Pop());
}
oldState.Dispose();
currentStateAction = newState;
RaiseStateChange(oldState.WorkflowStateType, newState.WorkflowStateType);
if (StateActionRules.NeedsDeviceRecovery)
{
if (currentStateAction.DoDeviceDiscovery())
{
StateActionRules.NeedsDeviceRecovery = false;
}
}
await newState.DoWork();
}
public async Task Error(IDeviceStateAction state)
{
if (state.WorkflowStateType == DeviceWorkflowState.None)
{
// TODO: Modify this workflow so that it follows the pattern and simply loops back around
// to the same final state. In this way, we would run through Shutdown once and then simply
// decide at that point to stop the workflow because we have no more states to advance to.
StopWorkflow();
RaiseOnWorkflowStopped(state.StopReason);
}
else
{
await AdvanceActionWithState(state);
}
}
private async Task AdvanceStateActionTransition(IDeviceStateAction oldState)
{
IDeviceStateAction newState = stateActionController.GetNextAction(oldState);
if (savedStackState.Count > 0)
{
newState.SetState(savedStackState.Pop());
}
oldState.Dispose();
currentStateAction = newState;
LogStateChange(oldState.WorkflowStateType, newState.WorkflowStateType);
await newState.DoWork();
}
public void GetNextAction_ShouldReturnCorrectType_When_Called(Type expectedType, DeviceWorkflowState initialState, bool set = true, bool exception = false)
{
TestHelper.Helper.SetFieldValueToInstance <IDeviceStateAction>("currentStateAction", false, false, subject, null);
if (set)
{
var map = TestHelper.Helper.GetFieldValueFromInstance <ReadOnlyDictionary <DeviceWorkflowState, Func <IDeviceStateController, IDeviceStateAction> > >(
"workflowMap", false, false, subject);
IDeviceStateAction action = map[initialState](stubManager);
if (exception)
{
TestHelper.Helper.SetPropertyValueToInstance <StateException>("LastException", true, false, action, new StateException());
}
TestHelper.Helper.SetFieldValueToInstance <IDeviceStateAction>("currentStateAction", false, false, subject, action);
}
Assert.IsType(expectedType, subject.GetNextAction(initialState));
}
public DeviceStateMachineAsyncManager(ref Mock <IDeviceStateController> mockController, IDeviceStateAction stateAction)
: this()
{
mockController.Setup(e => e.Complete(stateAction)).Callback(() => resetEvent.Set());
mockController.Setup(e => e.Error(stateAction)).Callback(() => resetEvent.Set());
}
private void ExecuteFinalState()
{
using IDeviceStateAction lastAction = stateActionController.GetFinalState();
lastAction.DoWork().Wait(2000);
}
//internal void PublishEventHandler(LinkEventResponse.EventTypeType eventType, LinkEventResponse.EventCodeType eventCode,
// List<LinkDeviceResponse> devices, LinkRequest request, string message)
//{
// string sessionId = request.Actions?[0]?.SessionID;
// if (!string.IsNullOrWhiteSpace(sessionId))
// {
// try
// {
// var eventToPublish = ComposeEvent(sessionId, eventType, eventCode, devices, request, new List<string>() { (message ?? string.Empty) }, online: DALListenerIsOnline);
// string jsonToPublish = JsonConvert.SerializeObject(eventToPublish);
// Connector.Publish(jsonToPublish, new string[] { TopicOption.Event.ToString() });
// }
// catch (Exception xcp)
// {
// LoggingClient.LogErrorAsync(xcp.Message);
// }
// }
//}
//internal void PublishEventHandlerAsTask(LinkEventResponse.EventTypeType eventType, LinkEventResponse.EventCodeType eventCode,
// List<LinkDeviceResponse> devices, LinkRequest request, string message)
//{
// _ = Task.Run(() => PublishEventHandler(eventType, eventCode, devices, request, message)).ConfigureAwait(false);
//}
//public LinkResponse ComposeEvent(string sessionId, LinkEventResponse.EventTypeType eventType,
// LinkEventResponse.EventCodeType eventCode, List<LinkDeviceResponse> devices, LinkRequest request, List<string> eventData,
// bool online = false)
//{
// var eventResponse = new LinkResponse()
// {
// MessageID = request?.MessageID,
// Responses = new List<LinkActionResponse>(1)
// {
// new LinkActionResponse()
// {
// MessageID = request.Actions?[0].MessageID,
// DALResponse = new LinkDALResponse()
// {
// Devices = devices,
// DALIdentifier = request?.Actions?[0].DALRequest?.DALIdentifier ?? DalIdentifier.GetDALIdentifier(),
// OnlineStatus = online
// },
// EventResponse = new LinkEventResponse()
// {
// EventCode = eventCode.ToString(),
// EventType = eventType.ToString(),
// EventID = Guid.NewGuid(),
// EventData = eventData == null ? null : eventData.ToArray(),
// OrdinalID = 0
// },
// SessionResponse = new LinkSessionResponse()
// {
// SessionID = sessionId
// }
// }
// }
// };
// if (eventResponse.Responses[0].DALResponse == null)
// {
// eventResponse.Responses[0].DALResponse = new LinkDALResponse();
// }
// if (eventResponse.Responses[0].DALResponse.DALIdentifier == null)
// {
// eventResponse.Responses[0].DALResponse.DALIdentifier = request.Actions?[0].LinkObjects?.ActionResponse?.DALResponse?.DALIdentifier;
// }
// if (eventResponse.Responses[0].DALResponse.Devices?[0] == null)
// {
// eventResponse.Responses[0].DALResponse.Devices = request.Actions?[0].LinkObjects?.ActionResponse?.DALResponse?.Devices ?? new List<LinkDeviceResponse>() { null };
// }
// return eventResponse;
//}
#region --- state machine management ---
public Task Complete(IDeviceStateAction state) => AdvanceStateActionTransition(state);
public async Task Recovery(IDeviceStateAction state, object stateObject)
{
SaveState(stateObject);
await AdvanceActionWithState(state);
}
protected Task Error(IDeviceStateAction state) => _ = Task.Run(() => Controller.Error(state));
protected Task Complete(IDeviceStateAction state) => _ = Task.Run(() => Controller.Complete(state));
