private async Task <MonitoredPort> EnsureMonitoredPort(SnmpTarget target, int portNumber)
{
var existingPort = await MonitoredPorts.Query()
.FirstOrDefaultAsync(port => port.PortNumber == portNumber && port.SnmpIpAddress == target.IpAddress);
if (existingPort == null)
{
var newPort = new MonitoredPort
{
AllInOctets = 0,
AllOutOctets = 0,
SnmpIpAddress = target.IpAddress,
PortNumber = portNumber,
FirstTimeScanned = DateTime.Now,
LastInOctets = 0,
LastOutOctets = 0,
ExcludeFromStatistics = false,
Comment = null
};
newPort = MonitoredPorts.Insert(newPort);
await Context.SaveAsync();
return(newPort);
}
return(existingPort);
}
public async Task <List <PortStatistics> > GetPortStatisticsForSwitch(string ipAddress)
{
var snmpTarget = await SnmpTargets.Query()
.FirstOrDefaultAsync(target => target.IpAddress == ipAddress);
if (snmpTarget == null)
{
throw new ArgumentException("ipAddress");
}
var monitoredPorts = await MonitoredPorts.Query()
.Where(port => port.SnmpIpAddress == ipAddress)
.Where(port => !port.ExcludeFromStatistics)
.ToListAsync();
var results = new List <PortStatistics>();
foreach (var monitoredPort in monitoredPorts)
{
var result = new PortStatistics
{
InboundTraffic = monitoredPort.AllInOctets,
MonitoredPort = monitoredPort,
OutboundTraffic = monitoredPort.AllOutOctets,
SnmpTarget = snmpTarget
};
results.Add(result);
}
return(results);
}
public async Task <List <PortStatistics> > GetOutboundHighscore(int countOfEntries)
{
var monitoredPorts = await MonitoredPorts.Query()
.Include(port => port.SnmpTarget)
.Where(port => !port.ExcludeFromStatistics)
.OrderByDescending(port => port.AllOutOctets)
.Take(countOfEntries)
.ToListAsync();
var results = new List <PortStatistics>();
foreach (var monitoredPort in monitoredPorts)
{
var result = new PortStatistics
{
InboundTraffic = monitoredPort.AllInOctets,
MonitoredPort = monitoredPort,
OutboundTraffic = monitoredPort.AllOutOctets,
SnmpTarget = monitoredPort.SnmpTarget
};
results.Add(result);
}
return(results);
}
public async Task <List <SwitchStatistics> > GetSwitchStatistics()
{
var snmpTargets = await SnmpTargets.Query()
.Include(_ => _.Group)
.ToListAsync();
var results = new List <SwitchStatistics>();
foreach (var snmpTarget in snmpTargets)
{
var target = snmpTarget;
try
{
var inboundTraffic = await MonitoredPorts.Query()
.Where(port => port.SnmpIpAddress == target.IpAddress)
.Where(port => !port.ExcludeFromStatistics)
.SumAsync(port => port.AllInOctets);
var outboundTraffic = await MonitoredPorts.Query()
.Where(port => port.SnmpIpAddress == target.IpAddress)
.Where(port => !port.ExcludeFromStatistics)
.SumAsync(port => port.AllOutOctets);
results.Add(new SwitchStatistics
{
InboundTraffic = inboundTraffic,
OutboundTraffic = outboundTraffic,
SnmpTarget = target,
Reachable = target.Reachable,
GroupName = target.Group.Name
});
}
catch (Exception)
{
// TODO: Logging
}
}
return(results);
}
public async Task WritePortReports(int year, int month, int day, int hour)
{
var startTime = new DateTime(year, month, day, hour, 0, 0);
var endTime = startTime.Add(new TimeSpan(1, 0, 0));
var inboundHighscore = await SnmpStatisticsService
.GetHighscore(int.MaxValue, startTime, endTime, TrafficType.Inbound);
var outboundHighscore = await SnmpStatisticsService
.GetHighscore(int.MaxValue, startTime, endTime, TrafficType.Outbound);
if (inboundHighscore == null || outboundHighscore == null)
{
throw new Exception("high score failure :(");
}
var reports = new List <PortReport>();
var monitoredPorts = await MonitoredPorts.Query().ToListAsync();
foreach (var monitoredPort in monitoredPorts)
{
var inboundStatistics = inboundHighscore
.FirstOrDefault(
stats =>
stats.MonitoredPort.SnmpIpAddress == monitoredPort.SnmpIpAddress &&
stats.MonitoredPort.PortNumber == monitoredPort.PortNumber);
var outboundStatistics = outboundHighscore
.FirstOrDefault(
stats =>
stats.MonitoredPort.SnmpIpAddress == monitoredPort.SnmpIpAddress &&
stats.MonitoredPort.PortNumber == monitoredPort.PortNumber);
if (inboundStatistics == null || outboundStatistics == null)
{
continue;
}
var currentReport = new PortReport
{
Day = day,
Hour = hour,
Month = month,
Year = year,
InboundTraffic = inboundStatistics.InboundTraffic,
OutboundTraffic = outboundStatistics.OutboundTraffic,
PortNumber = monitoredPort.PortNumber,
SnmpIpAddress = monitoredPort.SnmpIpAddress
};
reports.Add(currentReport);
}
PortReports.InsertRange(reports);
await Context.SaveAsync();
var itemsToDelete = await CollectedTrafficDatas.Query()
.Where(data => data.TimeScanned >= startTime)
.Where(data => data.TimeScanned <= endTime)
.ToListAsync();
itemsToDelete.ForEach(item => CollectedTrafficDatas.Delete(item));
await Context.SaveAsync();
}
private async Task ProcessTrafficResult(MonitoredPort port, long octets, TrafficType trafficType)
{
if (port.FirstTimeScanned == null)
{
port.FirstTimeScanned = DateTime.Now;
port.LastInOctets = 0;
port.LastOutOctets = 0;
port.AllInOctets = 0;
port.AllOutOctets = 0;
switch (trafficType)
{
case TrafficType.Inbound:
{
port.LastInOctets = octets;
port.AllInOctets = octets;
break;
}
case TrafficType.Outbound:
{
port.LastOutOctets = octets;
port.LastInOctets = octets;
break;
}
}
}
long lastOctets = 0;
long overallOctets = 0;
switch (trafficType)
{
case TrafficType.Inbound:
lastOctets = port.LastInOctets;
overallOctets = port.AllInOctets;
break;
case TrafficType.Outbound:
lastOctets = port.LastOutOctets;
overallOctets = port.AllOutOctets;
break;
}
if ((lastOctets - octets) > 10)
{
overallOctets += octets;
lastOctets = octets;
}
else
{
overallOctets += (octets - lastOctets);
lastOctets = octets;
}
switch (trafficType)
{
case TrafficType.Inbound:
port.LastInOctets = lastOctets;
port.AllInOctets = overallOctets;
break;
case TrafficType.Outbound:
port.LastOutOctets = lastOctets;
port.AllOutOctets = overallOctets;
break;
}
port.LastTimeScanned = DateTime.Now;
MonitoredPorts.Update(port);
await WriteTrafficData(port, octets, trafficType);
}
public async Task <List <PortStatistics> > GetHighscore(int countOfEntries, DateTime startTime, DateTime endTime,
TrafficType type)
{
try
{
var entriesInTimespan = await CollectedTrafficDatas.Query()
.Where(data => data.TrafficType == type)
.Where(data => data.DiffedTimeSpan != null)
.Include(data => data.MonitoredPort)
.Where(data => !data.MonitoredPort.ExcludeFromStatistics)
.GroupBy(data => data.MonitoredPort)
.Select(data => data.Where(inner => inner.TimeScanned >= startTime))
.Select(data => data.Where(inner => inner.TimeScanned <= endTime))
.Select(data => data.OrderBy(inner => inner.TimeScanned))
.Select(data => new
{
Sum = data.Sum(inner => inner.Octets),
Data = data
})
.OrderByDescending(data => data.Sum)
.Take(countOfEntries)
.ToListAsync();
var desiredSampledSeconds = (endTime - startTime).TotalSeconds;
var results = new List <PortStatistics>();
var monitoredPorts = await MonitoredPorts.Query()
.Include(port => port.SnmpTarget)
.ToListAsync();
foreach (var entry in entriesInTimespan)
{
var sampledSeconds = entry.Data.Sum(entity => entity.DiffedTimeSpan.Value.TotalSeconds);
var correctionFactor = (float)desiredSampledSeconds / sampledSeconds;
var trafficInSpan = (long)(correctionFactor * entry.Sum);
var result = new PortStatistics
{
MonitoredPort = monitoredPorts.FirstOrDefault(
port =>
port.SnmpIpAddress == entry.Data.FirstOrDefault().SnmpIpAddress&&
port.PortNumber == entry.Data.FirstOrDefault().PortNumber),
};
result.SnmpTarget = result.MonitoredPort.SnmpTarget;
result.Comment = result.MonitoredPort.Comment;
var bytesPerSecond = trafficInSpan / desiredSampledSeconds;
var ordinals = new[] { "", "K", "M", "G", "T", "P", "E" };
var ordinal = 0;
while (bytesPerSecond > 1024)
{
bytesPerSecond /= 1024;
ordinal++;
}
result.EstimatedSpeed = String.Format("{0} {1}b/s",
Math.Round(bytesPerSecond, 2, MidpointRounding.AwayFromZero),
ordinals[ordinal]);
switch (type)
{
case TrafficType.Inbound:
result.InboundTraffic = trafficInSpan;
break;
case TrafficType.Outbound:
result.OutboundTraffic = trafficInSpan;
break;
}
results.Add(result);
}
return(results);
}
catch
{
return(new List <PortStatistics>());
}
}
