public List <NcChannel> GetChannelsToLastCycleTest(NcMonitor monitor)
{
return(scenarioRepository
.GetItems(monitor.ScenarioId)
.Where(x => x.TestCycleInterval <= monitor.LastTestCycleInterval)
.Select(x => x.Channel).ToList());
}
public async Task SetLastTestCycleIntervalsAsync()
{
// Arrange
var expectedTimeSpan = new TimeSpan(2, 40, 42);
var expectedStatus = MonitorStatus.OK;
var monitor = new NcMonitor
{
LastTestCycleInterval = It.IsAny <TimeSpan>(),
StatusId = (int)expectedStatus,
};
var monitorRepo = new Mock <IMonitorRepository>();
IMonitorManager monitorManager = new MonitorManager(
It.IsAny <IChannelRepository>(),
monitorRepo.Object,
It.IsAny <IRecordRepository>(),
It.IsAny <IScenarioRepository>());
// Act
await monitorManager.SetLastTestCycleIntervalsAsync(
monitor, expectedTimeSpan);// TimeSpan je struct, neni potreba vytvaret novou referenci
// Assert
monitorRepo.Verify(x => x.UpdateAsyncWithoutResetTestCycleInterval(monitor), Times.Once());
Assert.Equal(expectedTimeSpan, monitor.LastTestCycleInterval);
Assert.Equal(expectedStatus, monitor.StatusEnum());
}
/// <summary>
/// Prida notifikaci o nahozeni do fronty.
/// </summary>
/// <param name="monitor"></param>
/// <returns></returns>
public async Task AddNotifyUpAsync(NcMonitor monitor)
{
await NotifyAsync(monitor,
$"[MONITORING UP] {monitor.Name}",
$"Monitor '{monitor.Name}' for url '{monitor.Url}' with verificaiton rule '{monitor.VerificationEnum()}={monitor.VerificationValue}' is now up.",
notifyUp : true);
}
public async Task RecordAsync(NcMonitor monitor, MonitorResult result)
{
var record = monitorManager.LastOpenedMonitorRecord(monitor.Id);
if (result.IsSuccess)
{
if ((record != null && record.EndDate == null) || monitor.StatusEnum() != MonitorStatus.OK)
{//ukonceni zaznamu
if (record != null)
{
await monitorManager.UpdateEndDateAsync(record, DateTime.Now);
}
await notificator.AddNotifyUpAsync(monitor);//poslani notifikace o tom ze web bezi, staci poslat pouze jendou.
await monitorManager.SetStatusAndResetLastTestCycleIntervalAsync(monitor, MonitorStatus.OK);
}
}
else
{ //nastala chyba
if (record == null || record.EndDate != null || monitor.StatusEnum() != MonitorStatus.Error)
{ //neexistuje zadny zaznam nebo jsou vsechny uzavreny
await monitorManager.SetStatusAndResetLastTestCycleIntervalAsync(monitor, MonitorStatus.Error);
await AddNewRecordAsync(monitor, result);
}
//posilani notifikaci se provadi stale dokud je monitor v chybovem stavu
await notificator.AddNotifyDownAsync(monitor);
}
}
public async Task SetStatusAndResetLastTestCycleIntervalAsync(
MonitorStatus oldStatus,
MonitorStatus newStatus)
{
// Arrange
var monitor = new NcMonitor
{
StatusId = (int)oldStatus,
LastTestCycleInterval = new TimeSpan(2, 3, 4),
};
var monitorRepo = new Mock <IMonitorRepository>();
IMonitorManager monitorManager = new MonitorManager(
It.IsAny <IChannelRepository>(),
monitorRepo.Object,
It.IsAny <IRecordRepository>(),
It.IsAny <IScenarioRepository>());
// Act
await monitorManager.SetStatusAndResetLastTestCycleIntervalAsync(
monitor,
newStatus);
// Assert
monitorRepo.Verify(x => x.UpdateAsync(monitor), Times.Once());
Assert.Equal(new TimeSpan?(), monitor.LastTestCycleInterval);
Assert.Equal(newStatus, monitor.StatusEnum());
}
private async Task AddNewRecordAsync(NcMonitor monitor, MonitorResult result)
{
await monitorManager.AddNewRecordAsync(new NcMonitorRecord
{
StartDate = DateTime.Now,
Monitor = monitor,
Note = GetLogMessage(result),
});
}
public async Task SetStatusAndResetLastTestCycleIntervalAsync(NcMonitor monitor, MonitorStatus status)
{
if (monitor.StatusEnum() != MonitorStatus.InActive)
{
monitor.StatusId = (int)status;
}
monitor.LastTestCycleInterval = null;
await monitorRepository.UpdateAsync(monitor);
}
private async Task NotifyAsync(NcMonitor monitor, string subject, string message, bool notifyUp)
{
TimeSpan?timeInErrorStatus = monitorManager.TimeInErrorStatus(monitor.Id);
if (notifyUp && timeInErrorStatus != null || //ma se odeslat upozorneni o nahozeni, ale monitor je stale v chybovem stavu
!notifyUp && timeInErrorStatus == null) //ma se odeslat upozorneni o spadnuti, ale monitor neni v chybovem stavu
{
return;
}
List <NcChannel> channels;
if (notifyUp)
{//oznamit vsem kanalum co j*z byly upozorneni, ze web j*z bezi
channels = monitorManager.GetChannelsToLastCycleTest(monitor);
}
else
{//oznamit vsem kanalum co jeste nebyly upozorneni a maji byt upozorneni
channels = monitorManager.GetChannelsBetweenLastErrorAndTestCycle(monitor, timeInErrorStatus ?? TimeSpan.Zero);
}
bool foundChannels = channels.Count > 0;
if (foundChannels)
{
foreach (NcChannel channel in channels)
{
ChannelType chnlType = channel.ChannelTypeEnum();
Func <NcChannelSubscriber, string> contactSelect;
switch (chnlType)
{
case ChannelType.Email:
contactSelect = x => x.User.Email;
break;
default:
logger.LogError($"Method '{nameof(NotifyAsync)}' is not implemented for '{chnlType.GetType()}.{chnlType}' yet.");
continue;
}
await queue.PushAsync(QueueType.Notification, new NotifyItem
{
ChannelType = chnlType,
Subject = subject,
Message = message,
Contact = string.Join(";", channel.NcChannelSubscriber.Select(contactSelect)),
});
}
await monitorManager.SetLastTestCycleIntervalsAsync(monitor, timeInErrorStatus);
}
}
public List <NcChannel> GetChannelsBetweenLastErrorAndTestCycle(NcMonitor monitor, TimeSpan testCycle)
{
if (testCycle.TotalHours >= 24)
{
testCycle = new TimeSpan(23, 59, 59);
}
return(scenarioRepository
.GetItems(monitor.ScenarioId)
.Where(x =>
(monitor.LastTestCycleInterval == null || //monitor jeste nebyl testovan
monitor.LastTestCycleInterval < x.TestCycleInterval) &&//nebo posledni testovaci cyklus monitoru je mensi nez testovaci cyklus aktualniho kanalu
x.TestCycleInterval <= testCycle)//a zaroven testovaci cyklus kanalu musi byt mensi nebo roven testovacimu cyklu ve vstupnim parametru
.Select(x => x.Channel).ToList());
}
/// <summary>
/// Prida notifikaci o vypadku do fronty.
/// </summary>
/// <param name="monitor"></param>
/// <returns></returns>
public async Task AddNotifyDownAsync(NcMonitor monitor)
{
NcMonitorRecord monitorRecord = monitorManager.LastOpenedMonitorRecord(monitor.Id);
if (monitorRecord == null)
{//vsechny zaznamy jsou j*z uzavreny, uz neni error.
return;
}
await NotifyAsync(monitor,
$"[MONITORING DOWN] {monitor.Name}",
$"Monitor '{monitor.Name}' for url '{monitor.Url}' with verificaiton rule '{monitor.VerificationEnum()}={monitor.VerificationValue}' is now down." +
$"\n\nRecord note: {monitorRecord.Note}",
notifyUp : false);
}
private MonitorResult CheckMonitor(NcMonitor monitor)
{
if (monitor.Enabled)
{
int timeout = (int)monitor.Timeout.TotalMilliseconds;
switch (monitor.VerificationEnum())
{
case MonitorVerification.Keyword:
return(FindKeywordOnWebsite(monitor.Url, monitor.VerificationValue, timeout));
case MonitorVerification.StatusCode:
return(CheckStatusCode(monitor.Url, monitor.VerificationValue, timeout));
}
return(MonitorResult.Failed($"{nameof(monitor.VerificationType)} '{monitor.VerificationTypeId} - {monitor.VerificationType}' not found."));
}
return(MonitorResult.Success);
}
public Task CheckMonitors(IServiceProvider serviceProvider, CancellationToken cancellationToken)
{
return(Task.Run(() =>
{
try
{
List <NcMonitor> monitorsToCheck = monitorManager.MonitorsToCheck();
foreach (NcMonitor monitor in monitorsToCheck)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
Task task = Task.Run(async() =>
{//kontroly jednotlivych monitoru spustime paralelne
try
{
//vytvoreni noveho scope, jelikoz kazde vlakno by melo mit vlastni scope
//muze se totiz stat, ze se napr. databazovi context uvolni
//a vlakno se na nej bude chtit stale dotazovat
using (IServiceScope scope = serviceProvider.CreateScope())
{
cancellationToken.ThrowIfCancellationRequested();
Monitoring monitoring = scope.ServiceProvider.GetService <Monitoring>();
//vyhledani monitoru v aktualnim scope (db contextu)
NcMonitor tmpMonitor = monitoring.monitorManager.FindMonitor(monitor.Id);
logger.LogInformation($"{tmpMonitor.Name}: Started monitor checking.");
await monitoring.CheckAndRecordMonitorAsync(tmpMonitor);
logger.LogInformation($"{tmpMonitor.Name}: Finished monitor checking.");
cancellationToken.ThrowIfCancellationRequested();
logger.LogInformation($"{tmpMonitor.Name}: Started send all notifications...");
bool saved = false;
while (!saved)
{
try
{
await monitoring.notificator.SendAllNotifications();
saved = true;
}
catch (DbUpdateConcurrencyException ex) {}
}
logger.LogInformation($"{tmpMonitor.Name}: Finished send all notifications...");
}
}
catch (Exception ex)
{
logger.LogError(ex, $"Error while checking monitor: {monitor.Id} - {monitor.Name}.");
await emailNotificator.SendEmailExceptionAsync(ex, $"Error while checking monitor: {monitor.Id} - {monitor.Name}.");
}
}, cancellationToken);
}
catch (Exception ex)
{
logger.LogError(ex, $"Error while creating and starting task to check monitor: {monitor.Id} - {monitor.Name}.");
emailNotificator.SendEmailExceptionAsync(ex, $"Error while creating and starting task to check monitor: {monitor.Id} - {monitor.Name}.");
}
}
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(CheckMonitors)}");
emailNotificator.SendEmailExceptionAsync(ex, $"{nameof(CheckMonitors)}");
}
}, cancellationToken));
}
private Task CheckAndRecordMonitorAsync(NcMonitor monitor)
{
var result = CheckMonitor(monitor);
return(monitorRecorder.RecordAsync(monitor, result));
}
public void GetChannelsToLastCycleTest(long monitorLastTestCycleTicks, int expectedCount)
{
// Arrange
var scenarioId = 2;
var scenarioItems = new List <NcScenarioItem>(new NcScenarioItem[]
{
new NcScenarioItem {
ScenarioId = 1, TestCycleInterval = TimeSpan.MinValue
},
new NcScenarioItem {
ScenarioId = 1, TestCycleInterval = TimeSpan.MaxValue
},
new NcScenarioItem
{
ScenarioId = 2,
TestCycleInterval = new TimeSpan(10),
Channel = new NcChannel {
Id = 2
},
},
new NcScenarioItem
{
ScenarioId = 2,
TestCycleInterval = new TimeSpan(20),
Channel = new NcChannel {
Id = 3
},
},
new NcScenarioItem
{
ScenarioId = 2,
TestCycleInterval = new TimeSpan(30),
Channel = new NcChannel {
Id = 4
},
},
new NcScenarioItem {
ScenarioId = 3, TestCycleInterval = TimeSpan.MinValue
},
new NcScenarioItem {
ScenarioId = 3, TestCycleInterval = TimeSpan.MinValue
},
new NcScenarioItem {
ScenarioId = 3, TestCycleInterval = TimeSpan.MaxValue
},
});
var monitor = new NcMonitor
{
ScenarioId = scenarioId,
LastTestCycleInterval = new TimeSpan(monitorLastTestCycleTicks),
};
var expected = scenarioItems
.Where(x => x.ScenarioId == scenarioId &&
x.TestCycleInterval <= monitor.LastTestCycleInterval)
.Select(x => x.Channel)
.ToList();
var scenarioRepo = new Mock <IScenarioRepository>();
scenarioRepo.Setup(x => x.GetItems(scenarioId))
.Returns((int targetId) => scenarioItems.Where(x => x.ScenarioId == targetId).AsQueryable());
IMonitorManager monitorManager = new MonitorManager(
It.IsAny <IChannelRepository>(),
It.IsAny <IMonitorRepository>(),
It.IsAny <IRecordRepository>(),
scenarioRepo.Object);
// Act
var actual = monitorManager.GetChannelsToLastCycleTest(monitor);
// Assert
Assert.Equal(expectedCount, actual.Count);
expected.ToExpectedObject().ShouldEqual(actual);
}
public async Task SetLastTestCycleIntervalsAsync(NcMonitor monitor, TimeSpan?timeSpan)
{
monitor.LastTestCycleInterval = timeSpan;
await monitorRepository.UpdateAsyncWithoutResetTestCycleInterval(monitor);
}
public static MonitorVerification VerificationEnum(this NcMonitor monitor)
{
return((MonitorVerification)monitor.VerificationTypeId);
}
public static MonitorStatus StatusEnum(this NcMonitor monitor)
{
return((MonitorStatus)monitor.StatusId);
}
public async Task RecordAsync(MonitorStatus oldStatus, MonitorStatus monitorResult, bool existLastRecord, bool lastRecordIsOpen)
{
// Arrange
var monitorResultSuccess = monitorResult != MonitorStatus.Error;
var lastRecordEndDate = existLastRecord && !lastRecordIsOpen
? new DateTime?(DateTime.MinValue)
: new DateTime?();
var monitor = new NcMonitor
{
Id = Guid.NewGuid(),
StatusId = (int)oldStatus,
};
var mRecord = new NcMonitorRecord
{
EndDate = lastRecordEndDate
};
var mResult = new MonitorResult
{
IsSuccess = monitorResultSuccess
};
var monitorManager = new Mock <IMonitorManager>();
monitorManager.Setup(x => x.LastOpenedMonitorRecord(monitor.Id))
.Returns(() =>
{
if (!existLastRecord || !lastRecordIsOpen)
{
return(null);
}
return(mRecord);
}).Verifiable();
monitorManager.Setup(x => x.UpdateEndDateAsync(mRecord, It.IsAny <DateTime>()))
.Returns(Task.CompletedTask);
monitorManager.Setup(x =>
x.SetStatusAndResetLastTestCycleIntervalAsync(monitor, monitorResult))
.Returns(Task.CompletedTask);
var notificator = new Mock <INotificator>();
notificator.Setup(x => x.AddNotifyUpAsync(monitor)).Returns(Task.CompletedTask);
notificator.Setup(x => x.AddNotifyDownAsync(monitor)).Returns(Task.CompletedTask);
var monitorRecorder = new MonitorRecorder(
It.IsAny <ILogger <MonitorRecorder> >(),
monitorManager.Object,
notificator.Object);
// Act
await monitorRecorder.RecordAsync(monitor, mResult);
// Assert
monitorManager.Verify();
if (monitorResultSuccess)
{
if ((existLastRecord && lastRecordIsOpen) || oldStatus != MonitorStatus.OK)
{//ukonceni zaznamu
if (existLastRecord && lastRecordIsOpen)
{
monitorManager.Verify(x => x.UpdateEndDateAsync(mRecord, It.IsAny <DateTime>()));
}
notificator.Verify(x => x.AddNotifyUpAsync(monitor));
monitorManager.Verify(x => x.SetStatusAndResetLastTestCycleIntervalAsync(monitor, MonitorStatus.OK));
}
}
else
{
if (!existLastRecord || !lastRecordIsOpen || oldStatus != MonitorStatus.Error)
{//neexistuje zadny zaznam nebo jsou vsechny uzavreny nebo aktualni status monitoru neni v chybovem stavu
monitorManager.Verify(x => x.SetStatusAndResetLastTestCycleIntervalAsync(monitor, MonitorStatus.Error));
}
notificator.Verify(x => x.AddNotifyDownAsync(monitor));
}
}
