public void ShouldRemoveMonitoringRequest()
{
// Arrange
var repository = new MonitoringRequestRepository(_fixture.Context);
var monitorRequest = new MonitorRequest()
{
MonitorId = Guid.NewGuid(), ResponseCode = 200
};
// Act
repository.Add(monitorRequest);
repository.Save();
monitorRequest = new MonitorRequest()
{
MonitorId = Guid.NewGuid(), ResponseCode = 200
};
repository.Add(monitorRequest);
repository.Save();
repository.Delete(monitorRequest);
var count = repository.GetAll();
//Assert
Assert.Single(count);
}
private void CheckForHighResponseTime(MonitorRequest request, RequestSummary requestSummary)
{
EventType type = Facade.EventTypeDomainController.GetTypeByName(StaticStrings.ResponseTimeHigh);
if (request.RequestTimeMiliSeconds > type.PeakValue)
{
//Lav notification
Notification notification = new Notification();
notification.Seen = false;
notification.Created = DateTime.Now;
notification = Facade.NotificationDomainController.Create(notification);
//request should have serverId SOMEDAY
// Facade.ServerDetailDomainController.GetLatestServerDetail(request.ServerId);
int serverInterval = Facade.SettingDomainController.GetValueByName(StaticStrings.ServerDetailInterval);
//If interval = 10min -> check 15min back
ServerDetail latestServerDetailSummary = Facade.ServerDetailDomainController.GetLatestServerDetailByInterval(serverInterval + (serverInterval / 2));
Event e = new Event();
e.Created = DateTime.Now;
e.Value = Convert.ToInt32(request.RequestTimeMiliSeconds);
e.EventTypeId = type.Id;
e.NotificationId = notification.Id;
e.RequestSummaryId = requestSummary == null ? 0 : requestSummary.Id;
e.ServerDetailId = latestServerDetailSummary == null ? 0 : latestServerDetailSummary.Id;
Facade.EventDomainController.Create(e);
}
}
public static void Execute(string ip, int port, bool human = false)
{
_pressedKey = "";
var items = new[]
{
"B", "C", "D", "F", "G", "H", "J", "K", "L",
"M", "N", "P", "Q", "R", "S", "T", "V", "W",
"X", "Y", "Z"
};
using (var actr = new ActRClient(ip, port))
{
actr.StartTraceMonitoring();
actr.LoadActrModel("ACT-R:tutorial;unit2;demo2-model.lisp");
actr.Reset();
var numberList = new List <dynamic>();
for (var i = 0; i < items.Length; ++i)
{
numberList.Add(i);
}
var indexes = actr.PermuteList(numberList.ToArray());
var targetItem = items[(long)indexes[0]];
var window = actr.OpenExpWindow("Letter difference", true);
actr.AddTextToWindow(window, targetItem, 125, 150);
AbstractAddCommandRequest addCommandRequest = new AddCommandRequest(KeyPressAction,
"unit2-key-press",
"unit2-key-press",
"Assignment 2 task output-key monitor");
actr.AddDispatcherCommand(addCommandRequest);
var modelDispatcherMonitor = new MonitorRequest("output-key", "unit2-key-press");
actr.AddDispatcherMonitor(modelDispatcherMonitor);
if (!human)
{
actr.InstallDevice(window);
actr.Run(10, true);
}
else
{
while (_pressedKey.Equals(""))
{
Thread.Sleep(1);
}
}
//actr.RemoveDispatcherMonitor("output-key", "unit2-key-press");
actr.RemoveDispatcherMonitor(modelDispatcherMonitor);
actr.RemoveDispatcherCommand("unit2-key-press");
actr.StopTraceMonitoring();
Console.WriteLine(targetItem.ToLower().Equals(_pressedKey.ToLower()));
}
}
public async Task <Monitor> UpdateAsync(MonitorRequest entity, object id)
{
return(await DbQuerySingleAsync <Monitor>("[dbo].[usp_MonitorUpdate]", new
{
entity.UserName,
entity.MonitorName,
Id = id
}).ConfigureAwait(false));
}
public async Task <ApiResponse> Post([FromBody] MonitorRequest request)
{
if (!ModelState.IsValid)
{
throw new ApiProblemDetailsException(ModelState);
}
var result = await _monitorManager.CreateAsync(request).ConfigureAwait(false);
return(new ApiResponse("Record successfully created.", result, Status201Created));
}
public async Task <ApiResponse> Put(long id, [FromBody] MonitorRequest request)
{
if (!ModelState.IsValid)
{
throw new ApiException(ModelState.AllErrors());
}
var result = await _monitorManager.UpdateAsync(request, id).ConfigureAwait(false);
return(new ApiResponse("Record successfully updated.", result, Status201Created));
}
public static async Task Run([OrchestrationTrigger] IDurableOrchestrationContext monitorContext, ILogger log)
{
MonitorRequest input = monitorContext.GetInput <MonitorRequest>();
if (!monitorContext.IsReplaying)
{
log.LogInformation($"Received monitor request. Location: {input?.Location}. Phone: {input?.Phone}.");
}
VerifyRequest(input);
DateTime endTime = monitorContext.CurrentUtcDateTime.AddHours(18);
if (!monitorContext.IsReplaying)
{
log.LogInformation($"Instantiating monitor for {input.Location}. Expires: {endTime}.");
}
while (monitorContext.CurrentUtcDateTime < endTime)
{
// Check the weather
if (!monitorContext.IsReplaying)
{
log.LogInformation($"Checking current weather conditions for {input.Location} at {monitorContext.CurrentUtcDateTime}.");
}
bool isClear = await monitorContext.CallActivityAsync <bool>("GetIsClear", input.Location);
if (isClear)
{
// It's not raining! Or snowing. Or misting. Tell our user to take advantage of it.
if (!monitorContext.IsReplaying)
{
log.LogInformation($"Detected clear weather for {input.Location}. Notifying {input.Phone}.");
}
await monitorContext.CallActivityAsync("SendGoodWeatherAlert", input.Phone);
break;
}
else
{
// Wait for the next checkpoint
var nextCheckpoint = monitorContext.CurrentUtcDateTime.AddMinutes(30);
if (!monitorContext.IsReplaying)
{
log.LogInformation($"Next check for {input.Location} at {nextCheckpoint}.");
}
await monitorContext.CreateTimer(nextCheckpoint, CancellationToken.None);
}
}
log.LogInformation($"Monitor expiring.");
}
private void GetBolumName()
{
MonitorRequest.OnDataLoaded = (monitor) =>
{
this.Dispatcher.Invoke(DispatcherPriority.Background, new Action(() =>
{
MonitorNameText.Text = monitor.Name;
}));
};
MonitorRequest.GetMonitor(Settings.MonitorId);
}
public void RequestMonitor(IInteractor monitor, MonitorRequest monitorRequest)
{
Log.Info($"Received monitor from {monitor} on \"{monitorRequest}\"");
if (monitorRequest.IsAdd)
{
_repository.AddMonitor(monitor, monitorRequest.Feed);
}
else
{
_repository.RemoveMonitor(monitor, monitorRequest.Feed, false);
}
}
public static void AddRequest(MonitorRequest req)
{
var requests = GetRequests();
requests.AddOrUpdate(req.ResourceId, req, (key, oldReq) =>
{
if(req.IssuedAt > oldReq.IssuedAt)
{
oldReq.IssuedAt = req.IssuedAt;
oldReq.AccessToken = req.AccessToken;
}
return oldReq;
});
}
/// <summary>
/// Making http request for monitoring url and save response results into database
/// </summary>
/// <param name="monitor"></param>
/// <returns></returns>
public async Task RequestUrlAndSaveDb(Monitor monitor)
{
try {
HttpResponseMessage request = null;
var monitorRequest = new MonitorRequest()
{
MonitorId = monitor.Id
};
try {
var client = new HttpClient();
client.Timeout = TimeSpan.FromSeconds(15);
request = await client.GetAsync(monitor.Url);
monitorRequest.ResponseCode = (short)request.StatusCode;
monitorRequest.ResponseMessage = request.StatusCode.ToString();
monitorRequest.IsSuccess = request.IsSuccessStatusCode;
}
catch (HttpRequestException requestException) {
monitorRequest.ResponseCode = 500;
monitorRequest.ResponseMessage = "ServerError";
monitorRequest.IsSuccess = false;
}
//Notification
if (!monitorRequest.IsSuccess)
{
var notificationModel = new NotificationModel {
DisplayName = "Down Time Alerter",
Subject = $"The Site Named {monitor.Name} Is Unreachable",
Message = $"The site named {monitor.Name} ({monitor.Url}) is unreachable. Response Code: {monitorRequest.ResponseCode}, Response Message: {monitorRequest.ResponseMessage}",
NotificationUserModel = new NotificationUserModel {
Mail = monitor.User.Email
}
};
NotificationService.Notify(notificationModel);
}
//Monitor Request Save
MonitoringRequestService.Add(monitorRequest);
MonitoringRequestService.Save();
//Monitor Update
UpdateMonitoringLastStatusAndLastCheckDate(monitor, monitorRequest.IsSuccess);
}
catch (Exception ex) {
Logger.LogError($"Error occured at HangfireService.RequestUrlAndSaveDb(Monitor monitor), {ex}");
}
}
private static void VerifyRequest(MonitorRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request), "An input object is required.");
}
if (request.Location == null)
{
throw new ArgumentNullException(nameof(request.Location), "A location input is required.");
}
if (string.IsNullOrEmpty(request.Phone))
{
throw new ArgumentNullException(nameof(request.Phone), "A phone number input is required.");
}
}
public void ShouldUpdateMonitoringRequest()
{
// Arrange
var repository = new MonitoringRequestRepository(_fixture.Context);
var monitorRequest = new MonitorRequest()
{
MonitorId = Guid.NewGuid(), ResponseCode = 200
};
// Act
repository.Add(monitorRequest);
repository.Save();
monitorRequest.ResponseCode = 500;
repository.Edit(monitorRequest);
repository.Save();
var result = repository.GetById(monitorRequest.Id);
//Assert
Assert.Equal(500, result.ResponseCode);
}
public static void RemoveRequest(MonitorRequest req)
{
var outVar = new MonitorRequest();
GetRequests().TryRemove(req.ResourceId, out outVar);
}
public async Task <Monitor> CreateAsync(MonitorRequest entity)
{
return(await DbQuerySingleAsync <Monitor>("[dbo].[usp_MonitorInsert]", entity).ConfigureAwait(false));
}
public static void Enqueue(MonitorRequest req)
{
GetInstance().requestQueue.Enqueue(req);
}
public HttpResponseMessage PostRequest(MonitorRequest request)
{
if (request == null)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
int interval = Facade.SettingDomainController.GetValueByName(StaticStrings.ResponseTimeInterval);
RequestSummary requestSummary = Facade.RequestSummaryDomainController.GetRequestSummaryLastMinutes(interval);
if (requestSummary == null)
{
requestSummary = Facade.RequestSummaryDomainController.CreateRequestSummary(requestSummary, interval);
}
//System.Configuration.ConfigurationManager.AppSettings["RequestTimeWatchUrl"];
if (request.Url.Contains(Model.Properties.Settings.Default["RequestTimeWatchUrl"].ToString()))
{
//total requests
var totalRequests = requestSummary.Requests;
//Current average time
var averageTime = requestSummary.ResponseTime;
//total request time
var totalRequestsTime = averageTime * totalRequests;
totalRequests++;
//the new average = total time + the requests time split by totalrequest + 1
var newAverageTime = (totalRequestsTime + (int)request.RequestTimeMiliSeconds) / totalRequests;
requestSummary.ResponseTime = newAverageTime;
requestSummary.Requests = totalRequests;
CheckForHighResponseTime(request, requestSummary);
Facade.RequestSummaryDomainController.UpdateRequestSummary(requestSummary);
}
UserSummary userSummary = Facade.UserSummaryDomainController.GetUserSummeryByUserAndRequestSummary(request.UserId, request.Device, requestSummary.Id);
if (userSummary != null)
{
userSummary.Request++;
Facade.UserSummaryDomainController.UpdateUserSummary(userSummary);
}
else
{
UserSummary newUserSummary = new UserSummary();
newUserSummary.UserId = request.UserId;
newUserSummary.DateTimeCreated = DateTime.Now;
newUserSummary.Device = request.Device;
newUserSummary.RequestSummaryId = requestSummary.Id;
newUserSummary.Request = 1;
Facade.UserSummaryDomainController.CreateUserSummary(newUserSummary);
if (request.Device == (int)MyEnums.DeviceTypes.Mobile)
{
requestSummary.MobileUsers++;
}
if (request.Device == (int)MyEnums.DeviceTypes.Web)
{
requestSummary.WebUsers++;
}
Facade.RequestSummaryDomainController.UpdateRequestSummary(requestSummary);
}
try
{
Request r = new Request();
r.DateCreated = DateTime.Now;
r.RequestTimeMiliSeconds = Convert.ToInt32(request.RequestTimeMiliSeconds);
r.Url = request.Url;
r.UserId = request.UserId;
r.Device = request.Device;
Facade.RequestDomainController.Create(r);
}
catch (Exception e)
{
log.Error("Error in request api controller. Request Part: " + e);
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
private Task <HttpResponseMessage> Monitor(MonitorRequest request)
{
return(_sut.Monitor(request)
.ExecuteAsync(It.IsAny <CancellationToken>()));
}
private static double Trial(ActRClient actr, bool runInRealTime, double onset)
{
_answers = new List <string>();
_responses = new List <string>();
actr.Reset();
int freq;
var row = actr.ActrRandom(3);
var window = actr.OpenExpWindow("Sperling Experiment", runInRealTime);
var letters = new dynamic[]
{
"B",
"C",
"D",
"F",
"G",
"H",
"J",
"K",
"L",
"M",
"N",
"P",
"Q",
"R",
"S",
"T",
"V",
"W",
"X",
"Y",
"Z"
};
letters = actr.PermuteList(letters);
for (var i = 0; i < 3; ++i)
{
for (var j = 0; j < 4; ++j)
{
var txt = letters[i + j * 4];
if (i == row)
{
_answers.Add((string)txt);
}
actr.AddTextToWindow(window, (string)txt, 75 + j * 50, 101 + i * 50);
}
}
actr.InstallDevice(window);
switch (row)
{
case 0:
freq = 2000;
break;
case 1:
freq = 1000;
break;
default:
freq = 500;
break;
}
actr.NewToneSound(freq, 0.5, onset);
actr.ScheduleEventRelative(
900 + actr.ActrRandom(200), "clear-exp-window",
new dynamic[] { window.Title });
AbstractAddCommandRequest addCommandRequest = new AddCommandRequest(list => KeyPressAction(list),
"sperling-response",
"KeyPressAction",
"Sperling task key press response monitor");
actr.AddDispatcherCommand(addCommandRequest);
var modelDispatcherMonitor = new MonitorRequest("output-key", "sperling-response");
actr.AddDispatcherMonitor(modelDispatcherMonitor);
actr.Run(30, runInRealTime);
actr.RemoveDispatcherMonitor("output-key", "sperling-response");
actr.RemoveDispatcherCommand("KeyPressAction");
var score = 0;
foreach (var s in _responses)
{
if (_answers.Contains(s.ToUpper()))
{
++score;
}
}
Console.Write("answers: [");
foreach (var a in _answers)
{
Console.Write("'" + a + "'");
}
Console.Write("]\n");
Console.Write("responses: [");
foreach (var r in _responses)
{
Console.Write("'" + r + "'");
}
Console.Write("]\n");
return(score);
}
