private async Task <MonitoringResult> TestAbbyyExecute(IRequestClient <AbbyyOcrTestRequest> requestClient)
{
var watch = new Stopwatch();
MonitoringResult result;
try
{
watch.Start();
var testResponse = (await requestClient.GetResponse <AbbyyOcrTestResponse>(new AbbyyOcrTestRequest())).Message;
watch.Stop();
result = new MonitoringResult
{
MonitoredServices = "Abbyy Execute",
Status = testResponse.Success ? HeartbeatStatus.Ok.ToString() : HeartbeatStatus.Nok.ToString(),
Message = testResponse.Success ? "Ok" : "Nok, Error: " + testResponse.Error,
ExecutionTime = watch.ElapsedMilliseconds
};
}
catch (Exception ex)
{
result = new MonitoringResult
{
MonitoredServices = "Abbyy Execute",
Status = HeartbeatStatus.Nok.ToString(),
Message = $"Viaduc service call failed. Exception: {ex.Message}",
ExecutionTime = watch.ElapsedMilliseconds
};
}
return(result);
}
/// <summary>
/// Updates the monitoring result of a failure, including all the degradation which will be updated
/// </summary>
/// <param name="failure">Failure which is changed</param>
/// <param name="monitoringResult">Requests an update of the failure</param>
public void UpdateMonitoringResult(IFailure failure, MonitoringResult monitoringResult)
{
// Checks, if the failure has changed
MonitoringResult oldResult;
if (_failureStatus.TryGetValue(failure, out oldResult))
{
if (oldResult == monitoringResult)
{
// No change of failure... so just return
return;
}
}
_failureStatus[failure] = monitoringResult;
// Go through all rulesets where the capability is dependent on the failure
var alreadyUpdated = new HashSet <ICapability>();
foreach (var ruleSet in _rules.Values)
{
UpdateDegradation(ruleSet.Capability, alreadyUpdated);
/*
* foreach (var rule in ruleSet.Rules
* .OfType<FailureRule>()
* .Where(x=> x.Failure.Equals(failure)))
* {
* if (rule.Failure.Equals(failure))
* {
* UpdateDegradation(ruleSet.Capability, alreadyUpdated);
* }
* }*/
}
}
private async Task <MonitoringResult> TestDir(IRequestClient <DirCheckRequest> requestClient)
{
var result = new MonitoringResult {
MonitoredServices = "DIR"
};
var watch = new Stopwatch();
try
{
watch.Start();
var response = (await requestClient.GetResponse <DirCheckResponse>(new DirCheckRequest())).Message;
watch.Stop();
if (response.Ok)
{
result.Status = HeartbeatStatus.Ok.ToString();
result.Message =
$"Ok, Product Version: {response.ProductVersion}, Product Name: {response.ProductName}, Repository Name: {response.RepositoryName}";
}
else
{
result.Status = HeartbeatStatus.Nok.ToString();
result.Message = "Nok";
}
}
catch (Exception ex)
{
result.Status = HeartbeatStatus.Nok.ToString();
result.Message = $"Viaduc service call failed which execute the test. Exception: {ex.Message}";
}
result.ExecutionTime = watch.ElapsedMilliseconds;
return(result);
}
// public void TryGetMonitoringResult(string application, Action<MonitoringServiceResult, ExternalApiInfoList> callback)
// {
// try
// {
// if (callback == null)
// {
// throw new ArgumentNullException("callback");
// }
//
// if (string.IsNullOrEmpty(application))
// {
// throw new ArgumentException("'application' can not be null or empty string");
// }
//
// Guid id;
// if (Guid.TryParse(application, out id) == false)
// {
// log.WarnFormat("TryGetExternalApiInfo: Invalid Application ID format: {0}. No external API info loaded for app ID {1}.", application, id);
// callback(MonitoringServiceResult.Error, null);
// return;
// }
//
// this.TryGetMonitoringResultAsync(id, asyncRequestState => OnGetMonitoringResult(asyncRequestState, callback));
// return;
// }
// catch (Exception ex)
// {
// log.Error(ex);
// }
//
// log.WarnFormat("AccountService.GetApplication: No external API info loaded for app ID {0}.", application);
// callback(MonitoringServiceResult.Error, null);
// }
#endregion
#region Private Methods
#region Async Mode Code
private static void OnGetMonitorResultForVerifing(AsyncRequestState asyncRequestState, Action <MonitoringResult, object> callback, object state)
{
MonitoringResult result;
var appId = asyncRequestState.AppId.ToString();
try
{
switch (asyncRequestState.ResultCode)
{
case MonitoringServiceResult.Ok:
// account = new ApplicationAccount(appId, asyncRequestState.ResultCode, asyncRequestState.RequestResult);
result = new MonitoringResult(appId, asyncRequestState.ResultCode, asyncRequestState.RequestResult, null);
break;
case MonitoringServiceResult.NotFound:
// account = new ApplicationAccount(appId, asyncRequestState.ResultCode, false, ErrorMessages.InvalidAppId);
result = new MonitoringResult(appId, asyncRequestState.ResultCode, null, "Invalid AppId");
break;
default:
// account = new ApplicationAccount(appId, asyncRequestState.ResultCode, allowOnFailure, asyncRequestState.ErrorMessage);
result = new MonitoringResult(appId, asyncRequestState.ResultCode, null, asyncRequestState.ErrorMessage);
break;
}
}
catch (Exception e)
{
log.Warn(e);
// account = new ApplicationAccount(appId, AccountServiceResult.Error, allowOnFailure, e.Message);
result = new MonitoringResult(appId, MonitoringServiceResult.Error, null, e.Message);
}
callback(result, state);
}
/// <summary>
/// This method can be called by the inherited methods which define a specific failure
/// </summary>
/// <param name="failure">Failure, whose status shall be updated</param>
/// <param name="result">The monitoring result of the failure</param>
protected void ReportMonitoringResult(IFailure failure, MonitoringResult result)
{
if (Degrader == null)
{
throw new InvalidOperationException("Degrader is not set");
}
Degrader.UpdateMonitoringResult(failure, result);
}
public void Construct()
{
Assert.Throws <ArgumentNullException>(() => new MonitoringResult(null, "Test", bitmap));
Assert.Throws <ArgumentNullException>(() => new MonitoringResult(new FileInfo("XX1"), "Test", null));
var result = new MonitoringResult(new FileInfo("XX1"), "Test", bitmap);
Assert.AreEqual("Test", result.Class);
Assert.AreEqual("XX1", result.File.Name);
Assert.IsNotNull(result.Preview);
}
/// <summary>
/// Antes de iniciar a execução
/// </summary>
/// <param name="context"></param>
public void OnActionExecuting(ActionExecutingContext context)
{
result = new MonitoringResult
{
Action = context.ActionDescriptor.DisplayName,
Date = DateTime.UtcNow,
Parameters = context.ActionArguments,
};
stopwatch.Start();
}
public async Task Consume(ConsumeContext <TestElasticsearchRequest> context)
{
var watch = new Stopwatch();
var result = new MonitoringResult
{
MonitoredServices = "Elasticsearch"
};
try
{
watch.Start();
var testResponse = await dbAccess.GetElasticIndexHealth();
if (testResponse.IsReadOnly)
{
result.Status = HeartbeatStatus.Nok.ToString();
result.Message = "Error, Index is set to readonly!";
}
else if (testResponse.Health == "red")
{
result.Status = HeartbeatStatus.Nok.ToString();
result.Message = "Error, Index health-status is red!";
}
else if (testResponse.Status != "open")
{
result.Status = HeartbeatStatus.Nok.ToString();
result.Message = $"Error, Index status is {testResponse.Status}";
}
else
{
result.Status = HeartbeatStatus.Ok.ToString();
result.Message = $"Ok, Health: {testResponse.Health}, " +
$"Status: {testResponse.Status}, " +
$"IsReadOnly: {testResponse.IsReadOnly}, " +
$"DocsCount: {testResponse.DocsCount}";
}
}
catch (Exception ex)
{
result.Status = HeartbeatStatus.Nok.ToString();
Log.Error(ex, "Error when getting Index-Health-Status");
result.Message = "Error: Unknown Error when accessing Elastic (see Log)";
}
finally
{
watch.Stop();
result.ExecutionTime = watch.ElapsedMilliseconds;
}
await context.RespondAsync(new TestElasticsearchResponse
{
MonitoringResult = result
});
}
private async void _doWork(object sender, ElapsedEventArgs e)
{
Log.Logger.ForContext(typeof(MonitoringWorker)).Information("MonitoringWorker waking up...");
var endpoints = new List <MonitoredEndpoint>();
//var results = new List<MonitoringResult>();
using (var scope = _scopeFactory.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <DatabaseContext>();
endpoints = await dbContext.MonitoredEndpoint.ToListAsync();
}
foreach (var endpoint in endpoints)
{
var timeStamp = DateTime.Now;
if (!TimeTest(endpoint, timeStamp))
{
continue;
}
endpoint.DateOfLastCheck = timeStamp;
MonitoringResult result = new MonitoringResult();
result.DateOfCheck = timeStamp;
result.MonitoredEndpoint = endpoint;
try
{
var request = new HttpRequestMessage(HttpMethod.Get, new UriBuilder(endpoint.Url).Uri);
var client = _clientFactory.CreateClient();
try
{
var response = await client.SendAsync(request);
int statusCodeInt = ResolveStatusCode(response);
result.ReturnedPayload = await ExtractPayloadAsync(response);
}
catch (Exception ex)
{
result.ReturnedPayload = "SERVICE EXCEPTION: " + MySql.Data.MySqlClient.MySqlHelper.EscapeString(ex.Message);
}
}
catch (Exception ex)
{
Log.Logger.ForContext(typeof(MonitoringWorker)).Error(ex, String.Format("ERROR SENDING REQUEST TO ENDPOINT ID {0}", endpoint.Id));
}
await SaveMonitoringResultAsync(endpoint, result);
}
}
public void ApplyChange()
{
var file = Path.Combine(TestContext.CurrentContext.TestDirectory, @"Data\Data.txt");
var result = new MonitoringResult(new FileInfo(file), "Test", bitmap);
Path.Combine(TestContext.CurrentContext.TestDirectory, "Test").EnsureDirectoryExistence();
bool completed = false;
result.MoveRequest += (sender, args) => completed = true;
result.ApplyChange(new DirectoryInfo(TestContext.CurrentContext.TestDirectory));
Assert.IsTrue(completed);
}
public async Task StartAsync(MonitoringEntity entity)
{
var result = new MonitoringResult
{
CreatedDate = _dateTimeProvider.Now,
MonitoringEntityId = entity.Id
};
result.SetData(new PingMonitoringResultData(await GetIpStatus(entity)));
_monitoringResultRepository.Create(result);
await _monitoringResultRepository.SaveChangesAsync();
}
public SiteHealth Map(MonitoringResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (result.Data == null)
{
throw new ArgumentNullException(nameof(result.Data));
}
var typedData = result.GetData <PingMonitoringResultData>();
return(typedData.IpStatus == IPStatus.Success ? SiteHealth.Good : SiteHealth.Bad);
}
private async Task <MonitoringResult> TestRabbitMq()
{
var result = new MonitoringResult {
MonitoredServices = "RabbitMQ"
};
var watch = new Stopwatch();
var baseUri = WebHelper.GetStringSetting("rabbitMqManagementUri", string.Empty);
try
{
watch.Start();
var uriBuilder = new UriBuilder(baseUri);
uriBuilder.Path = "api/healthchecks/node";
var response = await rabbitMqHttpClient.GetAsync(uriBuilder.Uri);
var responseString = await response.Content.ReadAsStringAsync();
var responseJson = JsonConvert.DeserializeObject <RabbitMcHealthCheckResponse>(responseString);
if (responseJson.Status == "ok")
{
result.Message = "Ok, Health checks done";
result.Status = HeartbeatStatus.Ok.ToString();
}
else
{
result.Message = $"Nok, Reason from RabbitMQ: {responseJson.Reason}";
result.Status = HeartbeatStatus.Nok.ToString();
}
watch.Stop();
}
catch (Exception ex)
{
result.Message = $"Nok, Exception: {ex.Message}";
result.Status = HeartbeatStatus.Nok.ToString();
}
result.Message += $", Request uri: {baseUri}";
result.ExecutionTime = watch.ElapsedMilliseconds;
return(result);
}
private async Task <bool> OwnerTestAsync(MonitoringResult monitoringResult)
{
try
{
var resultOwner = await _context.MonitoredEndpoint.FirstOrDefaultAsync(x => x.Id == monitoringResult.MonitoredEndpointForeignKey);
if (resultOwner.Id != _owner.Data.Id)
{
return(false);
}
return(true);
}
catch (Exception ex)
{
_logger.LogError("ERROR RESOLVING OWNER", ex);
throw ex;
}
}
private async Task <MonitoringResult> TestAbbyyLicence(
IRequestClient <DocumentConverterInfoRequest, DocumentConverterInfoResponse> requestClient)
{
var watch = new Stopwatch();
MonitoringResult result;
try
{
watch.Start();
var infoResponse = await requestClient.Request(new DocumentConverterInfoRequest());
watch.Stop();
result = new MonitoringResult
{
MonitoredServices = "Abbyy Licence",
Status = infoResponse.PagesRemaining > 0 ? HeartbeatStatus.Ok.ToString() : HeartbeatStatus.Nok.ToString(),
ExecutionTime = watch.ElapsedMilliseconds
};
if (infoResponse.PagesRemaining == null)
{
result.Message = "Nok, Information missing. Abbyy not installed?";
}
else
{
result.Message = infoResponse.PagesRemaining > 0 ? "Ok" : "Nok";
result.Message += $", Remaining pages: {infoResponse.PagesRemaining}";
}
}
catch (Exception ex)
{
result = new MonitoringResult
{
MonitoredServices = "Abbyy Licence",
Status = HeartbeatStatus.Nok.ToString(),
Message = $"Viaduc service call failed. Exception: {ex.Message}",
ExecutionTime = watch.ElapsedMilliseconds
};
}
return(result);
}
private void HandleGetMonitoringResult(MonitoringResult monitoringResult, IRestRequestContext context)
{
if (monitoringResult.MonitoringServiceResult == MonitoringServiceResult.Ok)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("HandleGetMonitoringResult, response for app {0}: {1}", monitoringResult.ApplicationId, monitoringResult.Status);
}
context.SendResponse(monitoringResult.Status);
}
else
{
if (log.IsDebugEnabled)
{
log.DebugFormat("HandleGetMonitoringResult, MonitoringServiceResult {0}: {1}", monitoringResult.MonitoringServiceResult, monitoringResult.DebugMessage);
}
context.SendResponse("An error occured");
}
}
private async Task <MonitoringResult> TestAisDb(IRequestClient <AisDbCheckRequest, AisDbCheckResponse> requestClient)
{
var watch = new Stopwatch();
MonitoringResult result;
try
{
watch.Start();
var response = await requestClient.Request(new AisDbCheckRequest());
watch.Stop();
result = new MonitoringResult
{
MonitoredServices = "AIS DB",
ExecutionTime = watch.ElapsedMilliseconds
};
if (response.Ok)
{
result.Status = HeartbeatStatus.Ok.ToString();
result.Message = $"Ok, DB Version = {response.DbVersion}";
}
else
{
result.Status = HeartbeatStatus.Nok.ToString();
result.Message = $"Nok, Exception: {response.Exception.Message}";
}
}
catch (Exception ex)
{
result = new MonitoringResult
{
MonitoredServices = "AIS DB",
Status = HeartbeatStatus.Nok.ToString(),
Message = $"Viaduc service call failed which execute the test. Exception: {ex.Message}",
ExecutionTime = watch.ElapsedMilliseconds
};
}
return(result);
}
/// <inheritdoc />
public void AddRule(IFailure failure, MonitoringResult monitoringResult, ICapability targetCapability, int targetValue)
{
if (targetCapability.Degrader != null && targetCapability.Degrader != this)
{
throw new InvalidOperationException("Target Capability is already assigned to another degrader");
}
var ruleSet = GetRuleSetFor(targetCapability, true);
if (ruleSet == null)
{
throw new ArgumentNullException(nameof(ruleSet));
}
ruleSet.Rules.Add(
new FailureRule
{
Failure = failure,
ConditionValue = monitoringResult,
TargetCapability = targetValue
});
}
private async Task <MonitoringResult> TestElasticsearch(IRequestClient <TestElasticsearchRequest> requestClient)
{
MonitoringResult result;
try
{
var response = await requestClient.GetResponse <TestElasticsearchResponse>(new TestElasticsearchRequest());
result = response.Message.MonitoringResult;
}
catch (Exception ex)
{
result = new MonitoringResult
{
MonitoredServices = "Elasticsearch",
Status = HeartbeatStatus.Nok.ToString(),
Message = $"Viaduc service call failed which execute the test. Exception: {ex.Message}"
};
}
return(result);
}
private MonitoringResult TestDb()
{
var connectionString = ManagementSettingsViaduc.Instance.SqlConnectionString;
var watch = new Stopwatch();
watch.Start();
var data = new UserDataAccess(connectionString);
var testResult = data.TestDbAccess();
watch.Stop();
string message;
if (testResult <= 0)
{
message = "DB Version not found";
}
else if (testResult == 9999)
{
message = "DB Upgrade failed";
}
else
{
message = "Ok";
}
var result = new MonitoringResult
{
MonitoredServices = "DB",
Status = testResult > 0 && testResult != 9999
? HeartbeatStatus.Ok.ToString()
: HeartbeatStatus.Nok.ToString(),
ExecutionTime = watch.ElapsedMilliseconds,
Message = $"{message}, DB Version = {testResult}"
};
return(result);
}
public static List <MonitoringResult> GenerateMonitoringResult(int count, MonitoredEndpoint endpoint, User owner, int startId = 1)
{
var result = new List <MonitoringResult>();
count += startId;
for (int i = startId; i < count; i++)
{
MonitoringResult monitoringResult = new MonitoringResult()
{
Id = i,
DateOfCheck = DateTime.Now,
ReturnedHttpStatusCode = 100,
ReturnedPayload = String.Format("Payload for id {0}", i),
MonitoredEndpointForeignKey = endpoint.Id,
MonitoredEndpoint = endpoint
};
result.Add(monitoringResult);
}
return(result);
}
/// <summary>
/// Query all the monitored devices for data received by the hub
/// </summary>
/// <returns></returns>
public List<MonitoringResult> Monitor(string deviceId, int lastMaxSample = -1, int timeOut = 1)
{
if (_internalCallCount == 0)
timeOut = FIRST_CALL_TIMEOUT_SECONDS;
if (_monitoringResults == null)
_monitoringResults = new Dictionary<string, List<MonitoringResult>>();
try
{
int i = 0;
while(i < 2) // On the first call we need to execute the loop twice for some unknown Azure IoTHub
{
foreach (var e in _eventHubReceivers)
{
if (deviceId == e.Key.DeviceId)
{
// TODO: we need to get all the data from the start time
var eventDatas = _eventHubReceivers[e.Key].Receive(MAX_SAMPLE_TO_ASK_FOR_SINCE_START_TIME, TimeSpan.FromSeconds(timeOut));
foreach (var eventData in eventDatas)
{
var data = Encoding.UTF8.GetString(eventData.GetBytes());
DateTime enqueuedTime = eventData.EnqueuedTimeUtc.ToLocalTime();
var mr = new MonitoringResult {DeviceId = e.Key.DeviceId, EnqueuedTime = enqueuedTime};
mr.Properties = AzureIoTDevice.Deserialize<Dictionary<string, object>>(data);
if (!_monitoringResults.ContainsKey(deviceId))
_monitoringResults.Add(deviceId, new List<MonitoringResult>());
_monitoringResults[deviceId].Add(mr);
}
if (this._cancellationTokenSource != null)
this._cancellationTokenSource.Token.ThrowIfCancellationRequested();
}
}
i++;
if (_internalCallCount == 0)
Thread.Sleep(1000); // Looks like waiting 1 second and re trying make a difference
else
break;
}
}
catch (Exception ex)
{
if (this._cancellationTokenSource != null && this._cancellationTokenSource.Token.IsCancellationRequested)
{
Console.WriteLine("Exiting monitoring"); // Exit mode
}
else
{
Console.WriteLine(ex.ToString());
FailedState = true;
}
}
_internalCallCount++;
if (_monitoringResults.ContainsKey(deviceId))
{
// The data is order by : if we ask the 32 since the specified startTime
// We get the first 32 since the specified startTime and not the last
// For assume that we got all the sample since the specified startTime and
// and only key the LAST lastMaxSample
while (_monitoringResults[deviceId].Count > lastMaxSample)
{
//_monitoringResults[deviceId].RemoveAt(_monitoringResults[deviceId].Count-1);
_monitoringResults[deviceId].RemoveAt(0);
}
return _monitoringResults[deviceId];
}
else
return new List<MonitoringResult>();
}
public void GetMonitoringResultCallback(MonitoringResult monitoringResult, object state)
{
var context = (IRestRequestContext)state;
fiber.Enqueue(() => HandleGetMonitoringResult(monitoringResult, context));
}
/// <summary>
/// Construtor
/// </summary>
/// <param name="log">logger para monitoramento de endpoints</param>
public Monitoring(ILogger <Monitoring> log)
{
this.log = log;
result = new MonitoringResult();
stopwatch = new Stopwatch();
}
private async Task <bool> SaveMonitoringResultAsync(MonitoredEndpoint endpoint, MonitoringResult monitoringResult)
{
var result = false;
try
{
using (var scope = _scopeFactory.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <DatabaseContext>();
dbContext.MonitoredEndpoint.Update(endpoint);
dbContext.MonitoringResult.Add(monitoringResult);
await dbContext.SaveChangesAsync();
result = true;
}
}
catch (Exception ex)
{
Log.Logger.ForContext(typeof(MonitoringWorker)).Error(ex, String.Format("ERROR SAVING CHANGES TO DB FOR ENDPOINT ID {0}", endpoint.Id));
}
return(result);
}
