/// <summary>
/// Gets the Monitoring Info for the Server and populates it into the model
/// </summary>
/// <param name="apiClient"></param>
/// <param name="authInfo"></param>
/// <param name="serversDetails"></param>
/// <param name="detailsModel"></param>
/// <remarks>
/// Date: 24/06/2018
/// Author: Stephen McCutcheon
/// </remarks>
private static void GetMonitoringInfo(MyServersApiClient apiClient, AuthInfo authInfo, ServerInfo serversDetails,
ServerDetailModel detailsModel)
{
var monitorReport = apiClient.GetServerStatus(authInfo, serversDetails.ServiceID);
detailsModel.MonitorStatus = new List <MonitorStatusModel>();
if (monitorReport != null)
{
foreach (var mon in monitorReport)
{
var monitormodel = new MonitorStatusModel
{
TestId = mon.TestId,
TestName = mon.TestName,
TestType = mon.TestType,
StatusCode = mon.StatusCode,
MonitoredIp = mon.MonitoredIp,
StatusDetail = mon.StatusDetail,
LastUpdated = mon.LastUpdated,
LastStatusChange = mon.LastStatusChange
};
detailsModel.MonitorStatus.Add(monitormodel);
}
}
}
/// <summary>
/// Gets the Server Details
/// </summary>
/// <param name="serverId"></param>
/// <param name="apiClient"></param>
/// <param name="authInfo"></param>
/// <param name="detailsModel"></param>
/// <returns></returns>
/// <remarks>
/// Date: 24/06/2018
/// Author: Stephen McCutcheon
/// </remarks>
private static ServerInfo GetServerDetails(string serverId, MyServersApiClient apiClient, AuthInfo authInfo,
out ServerDetailModel detailsModel)
{
var serversDetails = apiClient.GetServerDetails(authInfo, serverId);
detailsModel = new ServerDetailModel()
{
ServerId = serversDetails.ServiceID,
ServerDescription = serversDetails.YourReference,
ServiceDescription = serversDetails.ServiceDescription,
IpAddresses = serversDetails.IPAddresses,
ReverseDns = new List <ServerDetailReverseDns>(),
HasReverseDnsEntry = false,
NoReverseDnsEntryMessage = Settings.Default.NoDNSInfo
};
return(serversDetails);
}
/// <summary>
/// Gets the Revers DNS Details Info
/// </summary>
/// <param name="serversDetails"></param>
/// <param name="detailsModel"></param>
/// <remarks>
/// Date: 24/06/2018
/// Author: Stephen McCutcheon
/// </remarks>
private static void GetReversDnsDetails(ServerInfo serversDetails, ServerDetailModel detailsModel)
{
if (serversDetails.ReverseDnsEntries != null &&
serversDetails.ReverseDnsEntries.Length > 0)
{
detailsModel.HasReverseDnsEntry = true;
foreach (var reverseDns in serversDetails.ReverseDnsEntries)
{
var serverRevDns = new ServerDetailReverseDns
{
HostName = reverseDns.HostName,
IpAddres = reverseDns.IPAddress
};
detailsModel.ReverseDns.Add(serverRevDns);
}
}
}
/// <summary>
/// Gets the bandwith width info from the server and populautes it into the model
/// </summary>
/// <param name="apiClient"></param>
/// <param name="authInfo"></param>
/// <param name="serversDetails"></param>
/// <param name="detailsModel"></param>
/// <remarks>
/// Date: 24/06/2018
/// Author: Stephen McCutcheon
/// </remarks>
private static void GetBandWidthInfo(MyServersApiClient apiClient, AuthInfo authInfo, ServerInfo serversDetails,
ServerDetailModel detailsModel)
{
var bandwithReport = apiClient.GetServerBandwidthReport(authInfo, serversDetails.ServiceID, true);
detailsModel.BandWidthInfo = new BandwithInfo
{
Bw24HIn = bandwithReport.BW24hIn,
Bw24HOutField = bandwithReport.BW24hOut,
Bw4HInField = bandwithReport.BW4hIn,
Bw4HOutField = bandwithReport.BW4hOut,
BwPredicted14DInField = bandwithReport.BWPredicted14dIn,
BwPredicted14DOutField = bandwithReport.BWPredicted14dOut,
BwPredicted24HInField = bandwithReport.BWPredicted24hIn,
BwPredicted24HOutField = bandwithReport.BWPredicted24hOut,
BwSofarThisMonthInField = bandwithReport.BWSofarThisMonthIn,
BwSofarThisMonthOutField = bandwithReport.BWSofarThisMonthOut
};
}
public HttpResponseMessage PostServerDetailCurrent(ServerDetailModel serverDetails)
{
try
{
if (serverDetails == null || serverDetails.ServerName == null)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
//Server regonized?
Server s = Facade.ServerDomainController.GetServerByName(serverDetails.ServerName);
if (s == null)
{
s = new Server();
s.Name = serverDetails.ServerName;
s = Facade.ServerDomainController.CreateServer(s);
}
//Create everytime!
ServerDetailCurrent currentServerDetail = new ServerDetailCurrent();
currentServerDetail.Handles = serverDetails.Handles;
currentServerDetail.Utilization = serverDetails.Utilization;
currentServerDetail.Thread = serverDetails.Thread;
currentServerDetail.Processes = serverDetails.Processes;
currentServerDetail.UpTime = serverDetails.Uptime;
currentServerDetail.RAMUtilization = serverDetails.RAMUtilization;
currentServerDetail.RAMAvailable = serverDetails.RAMAvailable;
currentServerDetail.RAMTotal = serverDetails.RAMTotal;
currentServerDetail.BytesReceived = serverDetails.BytesReceived;
currentServerDetail.BytesSent = serverDetails.BytesSent;
currentServerDetail.NetworkUtilization = serverDetails.NetworkUtilization;
currentServerDetail.ServerId = s.Id;
Facade.ServerDetailCurrentDomainController.CreateServerDetailCurrent(currentServerDetail);
//Styrer den sidste del af grafen (Bliver slettet løbende)
//ServerSummary hvert interval!
//der gemmes et summary hvert interval (10 MIN). DVS 13:35, består af data fra 13:30-13:40
//ved 13:30, kan vi gemme (summary 13:45)
//ved 13:40, kan vi gemme (summary 13:35) OSV
//KL 13:50:01, tjekker vi 15minutter tilbage (1,5 interval)
//Get the interval
int serverInterval = Facade.SettingDomainController.GetValueByName(StaticStrings.ServerDetailInterval);
//If interval = 10min -> check 15min back
ServerDetail latestServerDetailSummary = Facade.ServerDetailDomainController.GetLatestServerDetailByInterval(serverInterval + (serverInterval / 2));
//If null, create new
if (latestServerDetailSummary == null)
{
//get all servercurrent
List <ServerDetailCurrent> currentServerDetailsList = Facade.ServerDetailCurrentDomainController.GetAll();
//create new serverdetailSummary with the averages from all servercurrent
ServerDetail serverDetailSummary = new ServerDetail();
serverDetailSummary.Handles = Convert.ToInt32(currentServerDetailsList.Average(x => x.Handles));
serverDetailSummary.RAMAvailable = Convert.ToInt32(currentServerDetailsList.Average(x => x.RAMAvailable));
serverDetailSummary.RAMTotal = Convert.ToInt32(currentServerDetailsList.Average(x => x.RAMTotal));
serverDetailSummary.Thread = Convert.ToInt32(currentServerDetailsList.Average(x => x.Thread));
serverDetailSummary.Processes = Convert.ToInt32(currentServerDetailsList.Average(x => x.Processes));
serverDetailSummary.Utilization = Convert.ToInt32(currentServerDetailsList.Average(x => x.Utilization));
serverDetailSummary.ServerId = currentServerDetailsList.FirstOrDefault().ServerId;
serverDetailSummary.UpTime = currentServerDetailsList.LastOrDefault().UpTime;
serverDetailSummary.Created = GetStartOfInterval(DateTime.Now, serverInterval);
serverDetailSummary.BytesSent = currentServerDetailsList.Sum(x => x.BytesSent);
serverDetailSummary.BytesReceived = currentServerDetailsList.Sum(x => x.BytesReceived);
serverDetailSummary.NetworkUtilization = Convert.ToInt32(currentServerDetailsList.Average(x => x.NetworkUtilization));
latestServerDetailSummary = Facade.ServerDetailDomainController.Create(serverDetailSummary);
}
//Events - Could add more
RequestSummary requestSummary = Facade.RequestSummaryDomainController.GetRequestSummaryLastMinutes(serverInterval);
EventLogic ev = new EventLogic(); //Move most logic to this. Maybe make generic method for creating events?
Model.EventType cpuEventType = Facade.EventTypeDomainController.GetTypeByName(StaticStrings.CpuUsageHigh);
if (currentServerDetail.Utilization > cpuEventType.PeakValue)
{
//Notification
Notification n = Facade.NotificationDomainController.Create(new Notification());
//Event
Model.Event e = new Model.Event();
//ServerDetail -> tage nuværende snapshot, eller tage summary eller begge?
e.ServerDetailId = latestServerDetailSummary.Id; //Server summary
// requestSummary i dette tidsrum
e.RequestSummaryId = requestSummary == null ? 0 : requestSummary.Id;
e.Created = DateTime.Now;
e.EventTypeId = cpuEventType.Id;
e.NotificationId = n.Id;
e.Value = serverDetails.Utilization;
Model.Event createdEvent = Facade.EventDomainController.Create(e);
//Notify by email?
if (cpuEventType.Notify)
{
EmailManager emailManager = new EmailManager();
}
}
Model.EventType ramEventType = Facade.EventTypeDomainController.GetTypeByName(StaticStrings.LowMemory);
if (currentServerDetail.RAMAvailable < ramEventType.PeakValue)
{
//Notification
Notification n = Facade.NotificationDomainController.Create(new Notification());
//Event
Model.Event e = new Model.Event();
e.ServerDetailId = latestServerDetailSummary.Id;
e.RequestSummaryId = requestSummary == null ? 0 : requestSummary.Id;
e.Created = DateTime.Now;
e.EventTypeId = ramEventType.Id;
e.NotificationId = n.Id;
e.Value = serverDetails.RAMAvailable;
Model.Event createdEvent = Facade.EventDomainController.Create(e);
//Notify by email?
if (ramEventType.Notify)
{
EmailManager emailManager = new EmailManager();
}
}
}
catch (Exception e)
{
var response = new HttpResponseMessage(HttpStatusCode.BadRequest);
response.Content = new StringContent("Error: " + e);
return(response);
}
//Slet Dem her?
int setupInterval = Facade.SettingDomainController.GetValueByName(StaticStrings.ServerDetailInterval);
Facade.ServerDetailCurrentDomainController.DeleteAllOlderThanInterval(setupInterval);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
