private AlertDefinition GetAlertDefinitionFromFileName(string fileName)
{
TextReader textReader = null;
AlertDefinition alertDefinition = null;
try
{
XmlSerializer serializer = new XmlSerializer(typeof(AlertDefinition));
textReader = new StreamReader(fileName);
alertDefinition = (AlertDefinition)serializer.Deserialize(textReader);
}
catch (Exception ex)
{
MessageBox.Show("An error occurred whilst trying to load the alert definition : " + Environment.NewLine + Environment.NewLine + ex.Message,
"AuditWizard", MessageBoxButtons.OK, MessageBoxIcon.Error);
// JML TODO log this exception
return(null);
}
finally
{
// close text writer
textReader.Close();
}
return(alertDefinition);
}
private async Task UpdateAsync(AlertDefinition alertDefinition)
{
var dataObject = await(from a in _dbContext.AlertDefinitions.IncludeAllAlertCriteria()
where a.AlertDefinitionId == alertDefinition.AlertDefinitionId
select a).SingleAsync();
var criteria = dataObject.RootCriteria.Traverse(c => c.ChildrenCriteria);
var alertCriteriaToDelete = from ac in criteria
where !alertDefinition.ContainsAlertCriteriaId(ac.AlertCriteriaId)
select ac;
foreach (var ac in alertCriteriaToDelete)
{
if (_dbContext.Entry(ac) != null)
{
_dbContext.Entry(ac).State = EntityState.Deleted;
}
else
{
_dbContext.Remove(ac);
}
}
_mapper.Map(alertDefinition, dataObject);
_dbContext.Update(dataObject);
await _dbContext.SaveChangesAsync();
_mapper.Map(dataObject, alertDefinition);
}
private async Task <IEnumerable <AlertActionResult> > ProcessActionsAsync(AlertDefinition definition, Miner miner, AlertMetadata metadata, CancellationToken token)
{
var results = new List <AlertActionResult>();
if (!definition.Actions.Any())
{
return(results);
}
_logger.LogInformation($"Processing actions for alert definition {definition.Id}");
foreach (var action in definition.Actions)
{
foreach (var actionExecutor in _alertActionExecutors.Where(t => t.ShouldExecute(action, miner)))
{
_logger.LogInformation($"Processing action {action.Name} for alert definition {definition.Id}");
try
{
results.Add(await actionExecutor.ExecuteActionAsync(action, definition, miner, metadata, token));
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error executing action ({action.Name}) for alert definition {definition.Id}");
results.Add(new AlertActionResult
{
State = AlertActionState.Error,
ActionName = action.Name,
Message = "Error executing action"
});
}
}
}
_logger.LogInformation($"Finished processing actions for alert definition {definition.Id}");
return(results);
}
public override bool EndAlert(AlertDefinition definition, Miner miner, Alert alert, IEnumerable <Snapshot> snapshots, DateTime scanTime)
{
var snapshotsList = snapshots.ToList();
if (!snapshotsList.Any())
{
return(false);
}
var parameters = (GpuThresholdAlertParameters)definition.Parameters;
var conditionPeriods = (
from gpuCondition in snapshotsList.ToGpuConditions(stats => MapToCondition(stats, parameters))
from gpuConditionPeriod in gpuCondition.Periods
where gpuConditionPeriod.GpuIndex == alert.Metadata?.GpuIndex
orderby gpuConditionPeriod.Period.Start
select gpuConditionPeriod).ToList();
var conditionPeriod = conditionPeriods.LastOrDefault(s => s.Condition == alert.Metadata?.Value?.Condition);
if (conditionPeriod != null)
{
alert.Metadata = CreateMetadata(alert?.Metadata, parameters, conditionPeriod);
alert.DetailMessages = CreateDetailMessages(alert?.Metadata, parameters);
return(conditionPeriod.Period.HasEnd);
}
return(conditionPeriods.Any());
}
public Scan(AlertDefinition alertDefinition, Miner miner, IAlertScanner scanner, DateTime scanTime)
{
Definition = alertDefinition;
_miner = miner;
_scanner = scanner;
_scanTime = scanTime;
}
private async Task <Alert> CreateAlertAsync(AlertDefinition definition, Miner miner, HashrateAlertParameters parameters, IEnumerable <Snapshot> snapshots, CancellationToken token)
{
var metadata = CreateMetadata(null, parameters, snapshots);
var detailMessages = CreateDetailMessages(metadata, parameters);
return(await _alertFactory.CreateAlertAsync(definition, miner, metadata, "Hashrate too low", detailMessages, token));
}
private async Task <Alert> CreateAlertAsync(AlertDefinition definition, Miner miner, GpuThresholdAlertParameters parameters, GpuConditionPeriod conditionPeriod, CancellationToken token)
{
var metadata = CreateMetadata(null, parameters, conditionPeriod);
var detailMessages = CreateDetailMessages(metadata, parameters);
return(await _alertFactory.CreateAlertAsync(definition, miner, metadata, DefaultAlertMessage, detailMessages, token));
}
public virtual Period CalculateScanPeriod(AlertDefinition definition, DateTime scanTime)
{
var duration = definition.Parameters.DurationMinutes.MinutesToTimeSpan();
var paddedDuration = duration + duration;
return(definition.NextScanPeriod(scanTime, paddedDuration));
}
public async Task <bool> UpdateAsync(AlertDefinition alertDefinition, CancellationToken token = default)
{
var current = await _alertDefinitionRepository.FindByIdAsync(alertDefinition.Id, token);
if (current == null)
{
return(false);
}
alertDefinition.MinerId = current.MinerId;
alertDefinition.Created = current.Created;
alertDefinition.LastScan = current.LastScan;
alertDefinition.Updated = DateTime.UtcNow;
if (alertDefinition.Parameters.AlertType != current.Parameters.AlertType)
{
alertDefinition.Parameters = current.Parameters;
}
if (!current.Enabled && alertDefinition.Enabled)
{
alertDefinition.LastEnabled = DateTime.UtcNow;
}
else
{
alertDefinition.LastEnabled = current.LastEnabled;
}
return(await _alertDefinitionRepository.UpdateAsync(alertDefinition, token));
}
private bool PeakReached(AlertDefinition definition, int interval = 1)
{
var averageCPU = GetAverageCpu(interval);
var averageRAM = GetAverageRam(interval);
return(CpuOverPeak(definition.AvergareCPU, averageCPU) || RamOverPeak(definition.AvergareRAM, averageRAM));
}
public AlertDefinitionItemViewModel(
AlertDefinition alertDefinition,
INavigationService navigationService,
ILogger logger) : base(navigationService, logger)
{
_alertDefinition = alertDefinition ?? throw new ArgumentNullException(nameof(alertDefinition));
}
private void AssertAlertDefinition(AlertDefinition expected, AlertDefinition actual)
{
actual.AlertDefinitionId.Should().Be(expected.AlertDefinitionId);
actual.AppUser.AppUserId.Should().Be(expected.AppUser.AppUserId);
actual.Stock.StockId.Should().Be(expected.Stock.StockId);
AssertCriteria(expected.RootCriteria, actual.RootCriteria);
}
public async Task DeleteAsync(AlertDefinition alertDefinition)
{
var dataObject = _mapper.Map <Data.Model.AlertDefinition>(alertDefinition);
var childCriteria = dataObject.RootCriteria.Traverse(x => x.ChildrenCriteria);
_dbContext.RemoveRange(childCriteria);
_dbContext.AlertDefinitions.Remove(dataObject);
await _dbContext.SaveChangesAsync();
}
public FormAlertMonitorWizard(AlertDefinition alertDefinition)
{
InitializeComponent();
_alertDefinition = alertDefinition;
_editing = true;
_originalName = alertDefinition.Name;
wizardControl1.NextButtonEnabled = true;
}
public async Task <AlertDefinition> SaveAlertDefinitionAsync(AlertDefinition alertDefinition)
{
if (alertDefinition.AlertDefinitionId == Guid.Empty)
{
return(await PostAsync($"{MiscConstants.StockAlertsApiBaseUri}alert-definitions", alertDefinition));
}
return(await PutAsync($"{MiscConstants.StockAlertsApiBaseUri}alert-definitions/{alertDefinition.AlertDefinitionId}", alertDefinition));
}
private async Task InsertAsync(AlertDefinition alertDefinition)
{
var dataObject = _mapper.Map <Data.Model.AlertDefinition>(alertDefinition);
await _dbContext.AlertDefinitions.AddAsync(dataObject);
await _dbContext.SaveChangesAsync();
_mapper.Map(dataObject, alertDefinition);
}
public override bool EndAlert(AlertDefinition definition, Miner miner, Alert alert, IEnumerable <Snapshot> snapshots, DateTime scanTime)
{
var snapshotsList = snapshots.ToList();
if (!snapshotsList.Any())
{
return(false);
}
return(!ShouldAlert(definition, snapshotsList, scanTime));
}
public async Task SaveAsync(AlertDefinition alertDefinition)
{
if (alertDefinition.AlertDefinitionId == Guid.Empty)
{
await InsertAsync(alertDefinition);
}
else
{
await UpdateAsync(alertDefinition);
}
}
public async Task <ObjectResult> PostAsync([FromBody] AlertDefinition alertDefinition, CancellationToken token = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _alertDefinitionService.AddAsync(alertDefinition, token);
return(Ok(alertDefinition));
}
public async Task AddAsync(AlertDefinition alertDefinition, CancellationToken token = default)
{
alertDefinition.Id = Guid.NewGuid();
alertDefinition.Created = DateTime.UtcNow;
if (alertDefinition.Enabled)
{
alertDefinition.LastEnabled = DateTime.UtcNow;
}
await _alertDefinitionRepository.InsertAsync(alertDefinition, token);
}
public FormAlertTrigger(AlertDefinition alertDefinition, AlertTrigger alertTrigger)
{
InitializeComponent();
_alertDefinition = alertDefinition;
_alertTrigger = alertTrigger;
// Seems as if some attributes simply do not get set for the embedded SelectAuditDataFieldsControl so set them here
selectedFields.AllowExpandApplications = false;
selectedFields.AllowInternetSelection = true;
selectedFields.ReportSpecificItemsShow = false;
selectedFields.NodeStyle = NodeStyle.Standard;
}
private void InitNotificationManager()
{
var notificationProvider = new PushbulletNotificationProvider(Settings.Default.PushbulletApiKey);
var definition = new AlertDefinition(notificationProvider);
definition.AvergareCPU = Settings.Default.AlertAvergareCPU;
definition.AvergareRAM = Settings.Default.AlertAvergareRAM;
definition.MeasurementTime = Settings.Default.AlertMeasurementTime;
_notificationManager = new NotificationManager(new[] { definition }, _processMonitor);
}
public async Task <ObjectResult> PutAsync([FromBody] AlertDefinition alertDefinition, CancellationToken token = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!await _alertDefinitionService.UpdateAsync(alertDefinition, token))
{
return(NotFound(null));
}
return(Ok(alertDefinition));
}
private Notification CreatePeakStartNotification(AlertDefinition definition)
{
var notification = new Notification();
var interval = definition.MeasurementTime;
var body = DateTime.Now.ToString() + Environment.NewLine
+ "Average peak in the last " + interval + " min:" + Environment.NewLine
+ GetProcessNotificationLine(definition)
+ "CPU: " + GetAverageCpu(interval) + "%" + Environment.NewLine
+ "RAM: " + GetAverageRam(interval) + "%";
notification.Title = "Performance Monitor Alert from " + Environment.MachineName;
notification.Body = body;
return(notification);
}
public void CpuPeakReachedTest()
{
var definitions = new List <AlertDefinition>();
NotificationManager manager = new NotificationManager(definitions, null);
int current = 60,
average1 = 59,
average2 = current,
average3 = 61;
var eventT1 = new PerformanceState()
{
AverageCPU = current
};
manager.Update(eventT1);
var definition1 = new AlertDefinition(NotificationProviderMock.Object)
{
AvergareCPU = average1,
AvergareRAM = 30,
MeasurementTime = 10
};
var definition2 = new AlertDefinition(NotificationProviderMock.Object)
{
AvergareCPU = average2,
AvergareRAM = 30,
MeasurementTime = 10
};
var definition3 = new AlertDefinition(NotificationProviderMock.Object)
{
AvergareCPU = average3,
AvergareRAM = 30,
MeasurementTime = 10
};
PrivateObject obj = new PrivateObject(manager);
var value1 = (bool)obj.Invoke("PeakReached", new object[] { definition1, 1 });
var value2 = (bool)obj.Invoke("PeakReached", new object[] { definition2, 1 });
var value3 = (bool)obj.Invoke("PeakReached", new object[] { definition3, 1 });
Assert.IsTrue(value1);
Assert.IsFalse(value2);
Assert.IsFalse(value3);
}
public EditAlertDefinitionPageViewModel(
IAlertDefinitionsService alertDefinitionsService,
INavigationService navigationService,
ILogger logger) : base(navigationService, logger)
{
_alertDefinitionsService = alertDefinitionsService ?? throw new ArgumentNullException(nameof(alertDefinitionsService));
_alertDefinition = new AlertDefinition
{
RootCriteria = new AlertCriteria
{
Type = CriteriaType.Composite,
Operator = CriteriaOperator.And
}
};
Title = "Create Alert Definition";
}
public void NotifyTest()
{
var notificationProviderMock = new Mock <INotificationProvider>();
var definition = new AlertDefinition(notificationProviderMock.Object);
definition.NotifyDeviceIds.AddRange(new[] { "1", "2", "3" });
var manager = new NotificationManager(new[] { definition }, null);
notificationProviderMock.Setup(_ => _.Notify(It.IsAny <Notification>(), definition.NotifyDeviceIds)).Verifiable();
PrivateObject obj = new PrivateObject(manager);
obj.Invoke("Notify", new object[] { new Notification(), definition });
notificationProviderMock.Verify();
}
public async Task <Alert> CreateAlertAsync(AlertDefinition definition, Miner miner, AlertMetadata metadata, string defaultMessage, IEnumerable <string> detailMessages, CancellationToken token)
{
var now = DateTime.UtcNow;
return(new Alert
{
MinerId = definition.MinerId,
AlertDefinitionId = definition.Id,
Severity = definition.Severity ?? AlertSeverity.None,
Message = definition.Parameters?.AlertMessage ?? defaultMessage,
DetailMessages = detailMessages,
Metadata = metadata,
Start = now,
LastActive = now,
ActionResults = await ProcessActionsAsync(definition, miner, metadata, token)
});
}
public async Task <IActionResult> PostAsync([FromBody] AlertDefinition requestBody)
{
if (requestBody.AlertDefinitionId != Guid.Empty)
{
throw new BadRequestException("AlertDefinitionId must be empty on a POST.");
}
var alertDefinition = _mapper.Map <Domain.Model.AlertDefinition>(requestBody);
alertDefinition.AppUserId = HttpContext.User.GetAppUserIdClaim();
await alertDefinition.SaveAsync();
alertDefinition = await _alertDefinitionsService.GetAlertDefinitionAsync(alertDefinition.AlertDefinitionId);
var resource = _mapper.Map <AlertDefinition>(alertDefinition);
return(new OkObjectResult(resource));
}
public void CreateSpecification_AlertDefinitionWithMultipleCriteria_SpecificationCreated()
{
// Arrange
var factory = new AlertCriteriaSpecificationFactory();
var alertDefinitionsRepositoryMock = new Mock <IAlertDefinitionsRepository>();
var notificationServiceMock = new Mock <INotificationsService>();
var rootCriteriaId = Guid.NewGuid();
var alertDefinition = new AlertDefinition(alertDefinitionsRepositoryMock.Object, factory, notificationServiceMock.Object)
{
RootCriteria = new AlertCriteria
{
Type = CriteriaType.Composite,
Operator = CriteriaOperator.And,
ChildrenCriteria = new List <AlertCriteria>
{
new AlertCriteria
{
Type = CriteriaType.Price,
Operator = CriteriaOperator.LessThanOrEqualTo,
Level = 50
},
new AlertCriteria
{
Type = CriteriaType.DailyPercentageGainLoss,
Operator = CriteriaOperator.LessThanOrEqualTo,
Level = -0.02M
}
}
}
};
// Act
var specification = factory.CreateSpecification(alertDefinition);
// Assert
specification.Should().BeOfType <AndSpecification <AlertEvaluationMessage> >();
var children = (specification as CompositeSpecification <AlertEvaluationMessage>).Children;
children.Count.Should().Be(2);
children.First().Should().BeOfType <PriceSpecification>();
children.Last().Should().BeOfType <DailyPercentageGainLossSpecification>();
}
