public bool CanProcess([NotNull] CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(true);
}
public static bool IsValid([NotNull] this CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.TryGetExceptionContextParams() == null);
}
public static AngleXContextParams TryGetAngleParam([NotNull] this CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.TryGet(AngleXContextParams.AngleContextParamId) as AngleXContextParams);
}
public static PumpingRequestContextParams TryGetAutoPumpingRequestParams([NotNull] this CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.TryGet(PumpingRequestContextParams.AutoPumpingParamsId) as PumpingRequestContextParams);
}
public static PressureCycleProcessingContextParams TryGetPressureParams([NotNull] this CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.TryGet(PressureCycleProcessingContextParams.PressureParamsId) as PressureCycleProcessingContextParams);
}
public static IterationCycleProcessingContextParams TryGetIterationParams([NotNull] this CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.TryGet(IterationCycleProcessingContextParams.IterationCycleProcessingParamsId) as IterationCycleProcessingContextParams);
}
public static CheckPointCycleProcessingContextParams TryGetCheckPointParams([NotNull] this CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.TryGet(CheckPointCycleProcessingContextParams.CheckPointContextParamsId) as CheckPointCycleProcessingContextParams);
}
public static ForcedDataCollectionRequestCycleProcessingContextParams TryGetForcedDataCollectionRequest(
[NotNull] this CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.TryGet(ForcedDataCollectionRequestCycleProcessingContextParams.ForcedDataCollectionRequestId) as ForcedDataCollectionRequestCycleProcessingContextParams);
}
public bool CanProcess(CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var forcedRequest = context.TryGetForcedDataCollectionRequest();
if (forcedRequest != null)
{
return(true);
}
var checkPointReachedParams = context.TryGetCheckPointParams();
return(checkPointReachedParams != null && checkPointReachedParams.NeedRequestPressureParams);
}
private void UpdateContex(Devices.Monitor.Infrastructure.PatientPressureParams param, CycleProcessingContext context)
{
context.AddOrUpdate(
new PressureCycleProcessingContextParams(
param.SystolicArterialPressure,
param.DiastolicArterialPressure,
param.AverageArterialPressure));
}
public async Task <CycleProcessingContext> ProcessAsync(CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!context.IsValid())
{
_logger.Warning($"{GetType().Name}: действие не будет выполнено, т.к. в обработке сеанса возникли ошибки");
return(context);
}
var needPumping = context.TryGetAutoPumpingRequestParams()?.IsAutoPumpingEnabled ?? false;
_logger?.Trace($"{GetType().Name}: накачка манжеты...");
if (!needPumping)
{
_logger?.Trace($"{GetType().Name}: накачка манжеты не требуется");
context.AddOrUpdate(new PumpingResultContextParams(true));
return(context);
}
var isFree = await _mutex
.WaitAsync(_blockWaitingTimeout)
.ConfigureAwait(false);
if (!isFree)
{
_logger?.Warning($"{GetType().Name}: предыдущий запрос еще выполняется. " +
$"Новый запрос не будет выполнен, т.к. прошло больше {_blockWaitingTimeout.TotalMilliseconds} мс");
return(context);
}
var retryCounts = context.TryGetAutoPumpingRequestParams()?.PumpingNumberOfAttempts ?? 0;
bool wasPumpingComleted;
try
{
var timeoutPolicy = Policy
.TimeoutAsync(_pumpingTimeout);
var recilencePolicy = Policy
.Handle <Exception>()
.WaitAndRetryAsync(
retryCounts,
retryAttemp => TimeSpan.FromSeconds(_defaultRetryTimeout.TotalSeconds),
(exception, timeSpan, localContext) =>
{
_logger?.Trace($"{GetType().Name}: накачнка манжеты не выполена. Будет выполнена " +
"повторная попытка.");
});
var policyWrap = Policy.WrapAsync(recilencePolicy, timeoutPolicy);
await policyWrap
.ExecuteAsync(_monitorController.PumpCuffAsync)
.ConfigureAwait(false);
wasPumpingComleted = true;
}
catch (DeviceConnectionException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.MonitorConnectionError,
e.Message,
e)));
wasPumpingComleted = false;
}
catch (TimeoutRejectedException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.PumpingTimeout,
"Накачка манжеты прервана по таймауту",
e)));
wasPumpingComleted = false;
}
catch (DeviceProcessingException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.PumpingError,
e.Message,
e)));
wasPumpingComleted = false;
}
catch (Exception e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.PumpingError,
e.Message,
e)));
wasPumpingComleted = false;
}
finally
{
_mutex.Release();
}
context.AddOrUpdate(new PumpingResultContextParams(wasPumpingComleted));
return(context);
}
public async Task <CycleProcessingContext> ProcessAsync([NotNull] CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!context.IsValid())
{
_logger.Warning($"{GetType().Name}: действие не будет выполнено, т.к. в обработке сеанса возникли ошибки");
return(context);
}
var angleParams = context.TryGetAngleParam();
if (angleParams == null)
{
var forcedRequest = context.TryGetForcedDataCollectionRequest();
forcedRequest?.CommonParamsSemaphore.SetResult(true);
return(context);
}
var isFree = await _mutex
.WaitAsync(_blockWaitingTimeout)
.ConfigureAwait(false);
if (!isFree)
{
_logger?.Warning($"{GetType().Name}: предыдущий запрос еще выполняется. " +
$"Новый запрос не будет выполнен, т.к. прошло больше {_blockWaitingTimeout.TotalMilliseconds} мс");
var forcedRequest = context.TryGetForcedDataCollectionRequest();
forcedRequest?.CommonParamsSemaphore.SetResult(true);
return(context);
}
PatientCommonParams param = null;
var sessionInfo = context.TryGetSessionProcessingInfo();
var cycleNumber = sessionInfo?.CurrentCycleNumber;
var iterationInfo = context.TryGetIterationParams();
var iterationNumber = iterationInfo?.CurrentIteration;
try
{
_logger?.Trace($"{GetType().Name}: запрос общих параметров пациента с таймаутом {_updatePatientParamTimeout.TotalMilliseconds} мс");
var timeoutPolicy = Policy.TimeoutAsync(_updatePatientParamTimeout);
param = await timeoutPolicy
.ExecuteAsync(_monitorController.GetPatientCommonParamsAsync)
.ConfigureAwait(false);
}
catch (DeviceConnectionException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.InversionTableConnectionError,
e.Message,
e,
cycleNumber,
iterationNumber)));
}
catch (TimeoutRejectedException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.PatientCommonParamsRequestTimeout,
"Получение общих параметров пациента прервано по таймауту",
e,
cycleNumber,
iterationNumber)));
}
catch (Exception e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.PatientCommonParamsRequestError,
e.Message,
e,
cycleNumber,
iterationNumber)));
}
finally
{
var forcedRequest = context.TryGetForcedDataCollectionRequest();
forcedRequest?.CommonParamsSemaphore.SetResult(true);
_mutex.Release();
if (param == null)
{
param = new PatientCommonParams(-1, -1, -1);
}
}
_logger?.Trace($"{GetType().Name}: текущие общие показатели: ЧСС - {param.HeartRate}, " +
$"ЧСД - {param.RepsirationRate}, " +
$"SPO2 - {param.Spo2}");
context.AddOrUpdate(
new CommonPatientCycleProcessingContextParams(
param.HeartRate,
param.RepsirationRate,
param.Spo2));
return(context);
}
public async Task <CycleProcessingContext> ProcessAsync([NotNull] CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!context.IsValid())
{
_logger.Warning($"{GetType().Name}: действие не будет выполнено, т.к. в обработке сеанса возникли ошибки");
return(context);
}
var isBlocked = await _mutex
.WaitAsync(_blockWaitingTimeout)
.ConfigureAwait(false);
if (!isBlocked)
{
_logger?.Warning($"{GetType().Name}: предыдущий запрос еще выполняется. " +
$"Новый запрос не будет выполнен, т.к. прошло больше {_blockWaitingTimeout.TotalMilliseconds} мс");
return(context);
}
var sessionInfo = context.TryGetSessionProcessingInfo();
var cycleNumber = sessionInfo?.CurrentCycleNumber;
var iterationInfo = context.TryGetIterationParams();
var iterationNumber = iterationInfo?.CurrentIteration;
try
{
var timeoutPolicy = Policy.TimeoutAsync(_bedControllerTimeout);
_logger?.Trace($"{GetType().Name}: запрос текущего угла наклона кровати по оси X с таймаутом {_bedControllerTimeout.TotalMilliseconds} мс");
var currentAngle = await timeoutPolicy.ExecuteAsync(_bedController
.GetAngleXAsync)
.ConfigureAwait(false);
context.AddOrUpdate(new AngleXContextParams(currentAngle));
}
catch (DeviceConnectionException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.InversionTableConnectionError,
e.Message,
e,
cycleNumber,
iterationNumber)));
}
catch (TimeoutRejectedException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.InversionTableTimeout,
"Получение текущего угла по оси X прервано по таймауту",
e,
cycleNumber,
iterationNumber)));
}
catch (Exception e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.UpdateAngleError,
e.Message,
e,
cycleNumber,
iterationNumber)));
}
finally
{
_mutex.Release();
}
return(context);
}
public async Task <CycleProcessingContext> ProcessAsync([NotNull] CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!context.IsValid())
{
_logger.Warning($"{GetType().Name}: действие не будет выполнено, т.к. в обработке сеанса возникли ошибки");
return(context);
}
var pumpingResult = context.TryGetAutoPumpingResultParams();
if (!(pumpingResult?.WasPumpingCompleted ?? false))
{
_logger?.Trace($"{GetType().Name}: получение данных не будет выполнено, " +
$"т.к. накачка манжеты завершилась неудачно");
var forcedRequest = context.TryGetForcedDataCollectionRequest();
forcedRequest?.PressureParamsSemaphore.SetResult(true);
return(context);
}
var isFree = await _mutex
.WaitAsync(_blockWaitingTimeout)
.ConfigureAwait(false);
if (!isFree)
{
_logger?.Warning($"{GetType().Name}: предыдущий запрос еще выполняется. " +
$"Новый запрос не будет выполнен, т.к. прошло больше " +
$"{_blockWaitingTimeout.TotalMilliseconds} мс");
var forcedRequest = context.TryGetForcedDataCollectionRequest();
forcedRequest?.PressureParamsSemaphore.SetResult(true);
return(context);
}
Devices.Monitor.Infrastructure.PatientPressureParams param = null;
var sessionInfo = context.TryGetSessionProcessingInfo();
var cycleNumber = sessionInfo?.CurrentCycleNumber;
var iterationInfo = context.TryGetIterationParams();
var iterationNumber = iterationInfo?.CurrentIteration;
try
{
_logger?.Trace($"{GetType().Name}: запрос показателей давления с таймаутом " +
$"{_updatePatientParamTimeout.TotalMilliseconds} мс");
var timeoutPolicy = Policy.TimeoutAsync(_updatePatientParamTimeout);
param = await timeoutPolicy.ExecuteAsync(
_monitorController
.GetPatientPressureParamsAsync)
.ConfigureAwait(false);
}
catch (DeviceConnectionException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.MonitorConnectionError,
e.Message,
e,
cycleNumber,
iterationNumber)));
}
catch (TimeoutRejectedException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.PatientPressureParamsRequestTimeout,
"Получение показателей давления пациента прервано по таймауту",
e,
cycleNumber,
iterationNumber)));
}
catch (Exception e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.PatientPressureParamsRequestError,
e.Message,
e,
cycleNumber,
iterationNumber)));
}
finally
{
var forcedRequest = context.TryGetForcedDataCollectionRequest();
forcedRequest?.PressureParamsSemaphore.SetResult(true);
_mutex.Release();
if (param == null)
{
param = GetDefaultParams();
}
}
_logger?.Trace($"{GetType().Name}: текущие показатели давления: систолическиое - {param.SystolicArterialPressure}, " +
$"диастолическое - {param.DiastolicArterialPressure}, " +
$"среднее - {param.AverageArterialPressure}");
UpdateContex(param, context);
return(context);
}
public Task <CycleProcessingContext> ProcessAsync([NotNull] CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!context.IsValid())
{
_logger.Warning($"{GetType().Name}: действие не будет выполнено, т.к. в обработке сеанса возникли ошибки");
return(Task.FromResult(context));
}
var sessionProcessingInfo = context.TryGetSessionProcessingInfo();
if (sessionProcessingInfo == null)
{
return(Task.FromResult(context));
}
var iterationParams = context.TryGetIterationParams();
if (iterationParams == null)
{
return(Task.FromResult(context));
}
var cycleNumber = sessionProcessingInfo.CurrentCycleNumber;
var iterationNumber = iterationParams.CurrentIteration;
try
{
var currentCycleNumber = sessionProcessingInfo.CurrentCycleNumber;
var currentIteration = iterationParams.CurrentIteration;
var nextIterationToEcgMeassuring = iterationParams.IterationToGetEcg;
var nextIterationToCommonParamsMeassuring = iterationParams.IterationToGetCommonParams;
var nextIterationToPressureParamsMeassuring = iterationParams.IterationToGetPressureParams;
_logger?.Trace($"{GetType().Name}: определение необходимости сбора параметров. Цикл {currentCycleNumber}, итерация {currentIteration}");
var ecgCheckPoint = new IterationBasedCheckPoint(currentCycleNumber, nextIterationToEcgMeassuring);
var commonParamsCheckPoint = new IterationBasedCheckPoint(currentCycleNumber, nextIterationToCommonParamsMeassuring);
var pressureParamsCheckPoint = new IterationBasedCheckPoint(currentCycleNumber, nextIterationToPressureParamsMeassuring);
var needRequestEcg = false;
if (currentIteration == nextIterationToEcgMeassuring)
{
needRequestEcg = !_ecgParamsCheckPoints.Contains(ecgCheckPoint);
if (needRequestEcg)
{
_ecgParamsCheckPoints.Add(ecgCheckPoint);
}
}
var needRequestCommonParams = false;
if (currentIteration == nextIterationToCommonParamsMeassuring)
{
needRequestCommonParams = !_commonParamsCheckPoints.Contains(commonParamsCheckPoint);
if (needRequestCommonParams)
{
_commonParamsCheckPoints.Add(commonParamsCheckPoint);
}
}
var needRequestPressureParams = false;
if (currentIteration == nextIterationToPressureParamsMeassuring)
{
needRequestPressureParams = !_pressureParamsCheckPoints.Contains(pressureParamsCheckPoint);
if (needRequestPressureParams)
{
_pressureParamsCheckPoints.Add(pressureParamsCheckPoint);
}
}
var ecgStatus = needRequestEcg
? "требуется"
: "не требуется";
var commonParamsStatus = needRequestCommonParams
? "требуется"
: "не требуется";
var pressureParamsStatus = needRequestPressureParams
? "требуется"
: "не требуется";
_logger?.Trace($"{GetType().Name}: Цикл {currentCycleNumber}, итерация {currentIteration}: запрос ЭКГ {ecgStatus}, запрос общих параметров {commonParamsStatus}, запрос давления {pressureParamsStatus}");
context.AddOrUpdate(
new CheckPointCycleProcessingContextParams(
needRequestEcg,
needRequestCommonParams,
needRequestPressureParams));
}
catch (Exception e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.Unknown,
e.Message,
e,
cycleNumber,
iterationNumber)));
}
return(Task.FromResult(context));
}
public async Task <CycleProcessingContext> ProcessAsync([NotNull] CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!context.IsValid())
{
_logger.Warning($"{GetType().Name}: действие не будет выполнено, т.к. в обработке сеанса возникли ошибки");
return(context);
}
var isBlocked = await _mutex
.WaitAsync(_blockWaitingTimeout)
.ConfigureAwait(false);
if (!isBlocked)
{
_logger?.Warning($"{GetType().Name}: предыдущий запрос еще выполняется. " +
$"Новый запрос не будет выполнен, т.к. прошло больше {_blockWaitingTimeout.TotalMilliseconds} мс");
return(context);
}
var sessionInfo = context.TryGetSessionProcessingInfo();
var cycleNumber = sessionInfo?.CurrentCycleNumber;
try
{
_logger?.Trace($"{GetType().Name}: запрос текущей итерации с тайаутом {_bedControllerTimeout.TotalMilliseconds} мс...");
var timeoutPolicy = Policy.TimeoutAsync(_bedControllerTimeout);
var currentIteration = await timeoutPolicy
.ExecuteAsync(_bedController
.GetCurrentIterationAsync)
.ConfigureAwait(false);
if (currentIteration == 0)
{
currentIteration = StartIterationNumber;
}
_logger?.Trace($"{GetType().Name}: текущая итерация - {currentIteration}");
_logger?.Trace($"{GetType().Name}: запрос следующей итерации для измерения общих параметров с тайаутом {_bedControllerTimeout.TotalMilliseconds} мс...");
var nextIterationToMeasuringCommonParams = await timeoutPolicy
.ExecuteAsync(_bedController
.GetNextIterationNumberForCommonParamsMeasuringAsync)
.ConfigureAwait(false);
_logger?.Trace(
$"{GetType().Name}: следующая итерация для измерения общих параметров - {nextIterationToMeasuringCommonParams}.");
_logger?.Trace($"{GetType().Name}: запрос следующей итерации для измерения давления с тайаутом {_bedControllerTimeout.TotalMilliseconds} мс...");
var nextIterationToMeasuringPressureParams = await timeoutPolicy
.ExecuteAsync(_bedController
.GetNextIterationNumberForPressureMeasuringAsync)
.ConfigureAwait(false);
_logger?.Trace(
$"{GetType().Name}: следующая итерация для измерения давления - {nextIterationToMeasuringPressureParams}.");
_logger?.Trace($"{GetType().Name}: запрос следующей итерации для измерения ЭКГ с тайаутом {_bedControllerTimeout.TotalMilliseconds} мс...");
var nextIterationToMeasuringEcg = await timeoutPolicy
.ExecuteAsync(_bedController
.GetNextIterationNumberForEcgMeasuringAsync)
.ConfigureAwait(false);
_logger?.Trace(
$"{GetType().Name}: следующая итерация для измерения ЭКГ - {nextIterationToMeasuringEcg}.");
context.AddOrUpdate(new IterationCycleProcessingContextParams(
iterationToGetEcg: nextIterationToMeasuringEcg,
currentIteration: currentIteration,
iterationToGetCommonParams: nextIterationToMeasuringCommonParams,
iterationToGetPressureParams: nextIterationToMeasuringPressureParams));
}
catch (DeviceConnectionException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.InversionTableConnectionError,
e.Message,
e,
cycleNumber)));
}
catch (TimeoutRejectedException e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.InversionTableTimeout,
"Получение информации об итерациях прервано по таймауту",
e,
cycleNumber)));
}
catch (Exception e)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.InversionTableProcessingError,
e.Message,
e,
cycleNumber)));
}
finally
{
_mutex.Release();
}
return(context);
}
public static SessionProcessingInfoContextParamses TryGetSessionProcessingInfo([NotNull] this CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.TryGet(SessionProcessingInfoContextParamses.TypeId) as SessionProcessingInfoContextParamses);
}
public async Task <CycleProcessingContext> ProcessAsync([NotNull] CycleProcessingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!context.IsValid())
{
_logger.Warning($"{GetType().Name}: действие не будет выполнено, т.к. в обработке сеанса возникли ошибки");
return(context);
}
var isBlocked = await _mutex
.WaitAsync(_blockWaitingTimeout)
.ConfigureAwait(false);
if (!isBlocked)
{
_logger?.Warning($"{GetType().Name}: предыдущий запрос еще выполняется. " +
$"Новый запрос не будет выполнен, т.к. прошло больше " +
$"{_blockWaitingTimeout.TotalMilliseconds} мс");
return(context);
}
try
{
var timeoutPolicy = Policy.TimeoutAsync(_bedControllerTimeout);
_logger?.Trace($"{GetType().Name}: запрос прошедшего времени с тайаутом " +
$"{_bedControllerTimeout.TotalMilliseconds} мс");
var elapsedTime = await timeoutPolicy
.ExecuteAsync(
_bedController.GetElapsedTimeAsync)
.ConfigureAwait(false);
_logger?.Trace($"{GetType().Name}: запрос оставшегося времени с тайаутом " +
$"{_bedControllerTimeout.TotalMilliseconds} мс");
var remainingTime = await timeoutPolicy
.ExecuteAsync(
_bedController.GetRemainingTimeAsync)
.ConfigureAwait(false);
_logger?.Trace($"{GetType().Name}: оставшееся время " +
$"{remainingTime} ");
_logger?.Trace($"{GetType().Name}: запрос длительности цикла с тайаутом " +
$"{_bedControllerTimeout.TotalMilliseconds} мс");
var cycleDuration = await timeoutPolicy
.ExecuteAsync(
_bedController.GetCycleDurationAsync)
.ConfigureAwait(false);
_logger?.Trace($"{GetType().Name}: запрос количества циклов с тайаутом " +
$"{_bedControllerTimeout.TotalMilliseconds} мс");
var cyclesCount = await timeoutPolicy
.ExecuteAsync(
_bedController.GetCyclesCountAsync)
.ConfigureAwait(false);
_logger?.Trace($"{GetType().Name}: запрос номера текущего цикла с тайаутом " +
$"{_bedControllerTimeout.TotalMilliseconds} мс");
var currentCycleNumber = await timeoutPolicy
.ExecuteAsync(
_bedController.GetCurrentCycleNumberAsync)
.ConfigureAwait(false);
if (currentCycleNumber == 0)
{
currentCycleNumber = StartCycleNumber;
}
var sessionProcessingInfo = new SessionProcessingInfoContextParamses(
elapsedTime,
remainingTime,
cycleDuration,
currentCycleNumber,
cyclesCount);
context.AddOrUpdate(sessionProcessingInfo);
}
catch (DeviceConnectionException ex)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(SessionProcessingErrorCodes.InversionTableConnectionError,
ex.Message,
ex)));
}
catch (TimeoutRejectedException ex)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(
SessionProcessingErrorCodes.InversionTableTimeout,
"Получение информации о сеансе прервано по таймауту",
ex)));
}
catch (Exception ex)
{
context.AddOrUpdate(
new ExceptionCycleProcessingContextParams(
new SessionProcessingException(SessionProcessingErrorCodes.InversionTableProcessingError,
ex.Message,
ex)));
}
finally
{
_mutex.Release();
}
return(context);
}
public bool CanProcess(CycleProcessingContext context)
{
return(true);
}
