/// <summary>
/// 获取Sequence执行结果
/// </summary>
public static RuntimeState GetSequenceState(StepTaskEntityBase stepEntry)
{
// TODO 因为Step中可能存在循环的情况，中间运行是否成功失败不确定，所以该处判断可能是无效的。需要后期优化
if (null == stepEntry || stepEntry.Result == StepResult.NotAvailable)
{
return(RuntimeState.NotAvailable);
}
bool isTimeout = false;
bool isError = false;
bool isAbort = false;
bool isFailed = false;
GetStepsResultFlag(stepEntry, ref isTimeout, ref isError, ref isAbort, ref isFailed);
if (isAbort)
{
return(RuntimeState.Abort);
}
if (isTimeout)
{
return(RuntimeState.Timeout);
}
if (isError)
{
return(RuntimeState.Error);
}
return(isFailed ? RuntimeState.Failed : RuntimeState.Success);
}
public static StepTaskEntityBase CreateStepModelChain(IList <ISequenceStep> steps, SlaveContext context,
int sequenceIndex)
{
StepTaskEntityBase root = null;
if (steps.Count == 0)
{
context.LogSession.Print(LogLevel.Debug, context.SessionId,
$"Empty steps created for sequence {sequenceIndex}");
return(StepTaskEntityBase.GetEmptyStepModel(context, sequenceIndex));
}
root = StepTaskEntityBase.GetStepModel(steps[0], context, sequenceIndex);
root.NextStep = null;
StepTaskEntityBase lastNode = root;
StepTaskEntityBase currentNode = null;
for (int i = 1; i < steps.Count; i++)
{
currentNode = StepTaskEntityBase.GetStepModel(steps[i], context, sequenceIndex);
lastNode.NextStep = currentNode;
lastNode = currentNode;
currentNode.NextStep = null;
}
return(root);
}
private void AddBreakPoints(IList <CallStack> breakPoints)
{
foreach (CallStack breakPoint in breakPoints)
{
string stackStr = breakPoint.ToString();
if (_breakPoints.ContainsKey(stackStr))
{
continue;
}
StepTaskEntityBase stepEntity = ModuleUtils.GetStepEntity(_context, breakPoint);
if (null == stepEntity)
{
continue;
}
_breakPoints.Add(stackStr, stepEntity);
stepEntity.PostListener += DebugBlocked;
}
}
public static bool IsSubStepPassed(StepTaskEntityBase stepEntry)
{
if (null == stepEntry)
{
return(true);
}
StepTaskEntityBase subStep = stepEntry;
while (null != subStep)
{
StepResult stepResult = subStep.Result;
if (ModuleUtils.IsStepFailed(stepResult) || !IsSubStepPassed(subStep.SubStepRoot))
{
return(false);
}
subStep = subStep.NextStep;
}
return(true);
}
/// <summary>
/// 获取子节点执行结果的状态
/// </summary>
private static void GetStepsResultFlag(StepTaskEntityBase stepEntry, ref bool isTimeout, ref bool isError,
ref bool isAbort, ref bool isFailed)
{
if (null == stepEntry)
{
return;
}
StepTaskEntityBase subStep = stepEntry;
while (null != subStep)
{
StepResult result = subStep.Result;
switch (result)
{
case StepResult.Failed:
isFailed = true;
break;
case StepResult.Abort:
isAbort = true;
break;
case StepResult.Timeout:
isTimeout = true;
break;
case StepResult.Error:
isError = true;
break;
default:
// ignore
break;
}
GetStepsResultFlag(subStep.SubStepRoot, ref isTimeout, ref isError, ref isAbort, ref isFailed);
subStep = subStep.NextStep;
}
}
private void DebugBlocked(StepTaskEntityBase stepTaskEntity)
{
_hitBreakPointsLock.EnterWriteLock();
// 暂停的场景
CoroutineHandle coroutineHandle = stepTaskEntity.Coroutine;
if (_hitBreakPoints.ContainsKey(coroutineHandle.Id))
{
_hitBreakPoints[coroutineHandle.Id] = stepTaskEntity;
}
// 断点命中的场景
else
{
_hitBreakPoints.Add(coroutineHandle.Id, stepTaskEntity);
}
_hitBreakPointsLock.ExitWriteLock();
CallStack breakPoint = stepTaskEntity.GetStack();
_watchDatas.Values.Clear();
foreach (string watchData in _watchDatas.Names)
{
string variableName = ModuleUtils.GetVariableNameFromParamValue(watchData);
_watchDatas.Values.Add(_context.VariableMapper.GetWatchDataValue(variableName, watchData));
}
DebugMessage debugMessage = new DebugMessage(MessageNames.BreakPointHitName, _context.SessionId,
breakPoint, false)
{
WatchData = _watchDatas
};
// 发送断点命中消息
_context.MessageTransceiver.SendMessage(debugMessage);
_context.LogSession.Print(LogLevel.Debug, _context.SessionId, $"Breakpoint hitted:{breakPoint}");
coroutineHandle.WaitSignal();
}
public static StepTaskEntityBase CreateSubStepModelChain(IList <ISequenceStep> steps, SlaveContext context, int sequenceIndex)
{
StepTaskEntityBase root = null;
if (steps.Count == 0)
{
return(root);
}
root = StepTaskEntityBase.GetStepModel(steps[0], context, sequenceIndex);
root.NextStep = null;
StepTaskEntityBase lastNode = root;
StepTaskEntityBase currentNode = null;
for (int i = 1; i < steps.Count; i++)
{
currentNode = StepTaskEntityBase.GetStepModel(steps[i], context, sequenceIndex);
lastNode.NextStep = currentNode;
lastNode = currentNode;
currentNode.NextStep = null;
}
return(root);
}
public void Enqueue(StepTaskEntityBase stepEntity)
{
_stepExecutionInfos.Enqueue(new StepExecutionInfo(stepEntity, StepResult.NotAvailable));
}
public static CallStack GetSequenceStack(int index, int coroutineId)
{
return(StepTaskEntityBase.GetCurrentStep(index, coroutineId).GetStack());
}
public StepExecutionInfo(StepTaskEntityBase stepEntity, StepResult result)
{
this.StepEntity = stepEntity;
this.StepResult = result;
}
public void OnPostListener(StepTaskEntityBase stepEntity)
{
PostListener?.Invoke(stepEntity);
}
