private void SetOverallStatus(HeartBeatDto heartbeatResults)
{
var result = string.Empty;
var gatewayApi = (HeartBeatDto)heartbeatResults.ServiceStatusHeartBeatResults.Single();
var statues = new List <string>
{
heartbeatResults.Status,
gatewayApi.Status
};
foreach (var service in gatewayApi.ServiceStatusHeartBeatResults)
{
statues.Add(service.Status);
if (service.ChildHeartBeat != null)
{
statues.Add(service.ChildHeartBeat.Status);
}
}
if (statues.Any(x => x.Contains("RED")))
{
result = "RED";
}
else if (statues.Any(x => x.Contains("AMBER")))
{
result = "AMBER";
}
else if (statues.Any(x => x.Contains("GREEN")))
{
result = "GREEN";
}
heartbeatResults.OverallStatus = result;
}
public void CallHeartbeatAsync_CallsHeartbeatProxyAndPopulatesDtoWithTimeSpan()
{
CaseflowPingDto dtoReturnedFromApi = new CaseflowPingDto();
_caseflowApiProxyMock.Setup(x => x.HitHeartBeat())
.Callback(() =>
{
Thread.Sleep(50);
})
.ReturnsAsync(dtoReturnedFromApi);
HeartBeatDto result = _caseflowHeartbeatProcess.CallHeartbeatAsync().Result;
_caseflowApiProxyMock.Verify(x => x.HitHeartBeat(), Times.Once);
Assert.AreEqual("Caseflow Ping From Account Service", result.ServiceName);
Assert.AreEqual(null, result.Details);
Assert.IsTrue(result.RunningElapsedTime.TotalMilliseconds >= 50);
Assert.IsTrue(result.TotalElapsedTime.TotalMilliseconds >= 50);
Assert.AreEqual(result.RunningElapsedTime, result.TotalElapsedTime); // same
Assert.AreEqual(null, result.Status);
Assert.AreEqual(null, result.ChildHeartBeat);
}
public void CallHeartbeatAsync_CallsProxyAndReturnsDto()
{
HeartBeatDto dtoReturned = new HeartBeatDto();
_caseflowHeartbeatProcessMock.Setup(x => x.CallHeartbeatAsync())
.ReturnsAsync(dtoReturned);
HeartBeatDto result = _caseflowHeartbeatService.CallHeartbeatAsync().Result;
_caseflowHeartbeatProcessMock.Verify(x => x.CallHeartbeatAsync(), Times.Once);
Assert.AreEqual(dtoReturned, result);
}
public void CheckApiGatewayHeartbeat_CallsProxy()
{
_loggerMock = new Mock <ILogger <ApiGatewayHeartbeatProcess> >();
_proxyMock = new Mock <IApiGatewayProxy>();
HeartBeatDto dtoReturnedFromProxy = new HeartBeatDto();
_proxyMock.Setup(x => x.CheckAllServices()).ReturnsAsync(dtoReturnedFromProxy);
IApiGatewayHeartbeatProcess process = new ApiGatewayHeartbeatProcess(_loggerMock.Object, _proxyMock.Object);
HeartBeatDto dtoReturnedFromProcess = process.CheckApiGatewayHeartbeat().Result;
_proxyMock.Verify(x => x.CheckAllServices(), Times.Once);
Assert.AreEqual(dtoReturnedFromProcess, dtoReturnedFromProxy);
}
public async Task <HeartBeatDto> CallHeartbeatAsync()
{
var stopWatch = new Stopwatch();
stopWatch.Start();
await _caseflowApiProxy.HitHeartBeat();
stopWatch.Stop();
var caseflowHeartbeat = new HeartBeatDto
{
ServiceName = "Caseflow Ping From Account Service",
RunningElapsedTime = stopWatch.Elapsed,
TotalElapsedTime = stopWatch.Elapsed
};
return(caseflowHeartbeat);
}
public async Task <IActionResult> CheckAccountService()
{
_logger.LogInformation("HeartBeatController CheckAccountService action account service");
var stopWatch = new Stopwatch();
stopWatch.Start();
var greenThreshold = _configuration.GetValue <int>("HeartBeat:GreenThreshold");
var redThreshold = _configuration.GetValue <int>("HeartBeat:RedThreshold");
var caseflowGreenThreshold = _configuration.GetValue <int>("HeartBeat:CaseflowGreenThreshold");
var caseflowredThreshold = _configuration.GetValue <int>("HeartBeat:CaseflowRedThreshold");
HeartBeatDto caseflowResult;
try
{
caseflowResult = await _caseflowHeartbeatService.CallHeartbeatAsync();
caseflowResult.SetStatus(caseflowGreenThreshold, caseflowredThreshold);
}
catch
{
caseflowResult = new HeartBeatDto
{
ServiceName = "Caseflow Ping From Account Service",
Status = "RED",
Details = "Account service is down or Caseflow is down"
};
}
stopWatch.Stop();
var result = new HeartBeatDto
{
ServiceName = "Financial Account Service",
TotalElapsedTime = stopWatch.Elapsed,
RunningElapsedTime = stopWatch.Elapsed - caseflowResult.RunningElapsedTime
};
result.SetStatus(greenThreshold, redThreshold);
result.ChildHeartBeat = caseflowResult;
return(Ok(result));
}
public async Task <HeartBeatDto> CallHeartbeatAsync()
{
HeartBeatDto gatewayApiResult;
try
{
gatewayApiResult = await _apiGatewayHeartbeatProcess.CheckApiGatewayHeartbeat();
}
catch
{
gatewayApiResult = new HeartBeatDto
{
ServiceName = "Financial Gateway API",
Status = "RED",
Details = "Cannot call Financial Gateway API from Financial Portal"
};
}
return(gatewayApiResult);
}
public IActionResult Index()
{
var greenThreshold = _heartbeatSetting.GreenThreshold;
var redThreshold = _heartbeatSetting.RedThreshold;
var stopWatch = new Stopwatch();
stopWatch.Start();
stopWatch.Stop();
var result = new HeartBeatDto
{
ServiceName = "Financial Portal",
TotalElapsedTime = stopWatch.Elapsed,
RunningElapsedTime = stopWatch.Elapsed
};
result.SetStatus(greenThreshold, redThreshold);
return(View(result));
}
private async Task <HeartBeatDto> GetHeartBeat()
{
var stopWatch = new Stopwatch();
var greenThreshold = _heartbeatSetting.GreenThreshold;
var redThreshold = _heartbeatSetting.RedThreshold;
stopWatch.Start();
var apiResult = await _apiGatewayHeartbeatService.CallHeartbeatAsync();
stopWatch.Stop();
var result = new HeartBeatDto
{
ServiceName = "Financial Portal",
TotalElapsedTime = stopWatch.Elapsed,
RunningElapsedTime = stopWatch.Elapsed - apiResult.TotalElapsedTime
};
result.SetStatus(greenThreshold, redThreshold);
result.ServiceStatusHeartBeatResults.Add(apiResult);
SetOverallStatus(result);
return(result);
}
