public void AddFinishedGame(int gameId, int playerId)
{
StatisticsRecord record = new StatisticsRecord();
record.Winner = this.db.Players.Get(playerId).UserName;
record.MoveCount = this.db.Moves.GetAll().Where(m => m.GameId == gameId).Count();
this.db.StatisticsRecords.Create(record);
this.db.Save();
var ships = this.db.Ships.GetAll().Where(s => s.Field.GameId == gameId && s.Field.PlayerId == playerId).ToList();
foreach (var ship in ships)
{
int injuredCells = ship.Coordinates.Where(c => c.Mark).Count();
// if ship isn't killed add it to winner's ships
if (injuredCells != ship.Size)
{
WinnerShip winnerShip = new WinnerShip();
winnerShip.Size = ship.Size;
winnerShip.InjuredCells = injuredCells;
winnerShip.StatisticsRecordId = record.Id;
this.db.WinnerShips.Create(winnerShip);
}
}
this.db.Save();
}
public static StatisticsRecord ConvertToStatistics(this RawCapture rawCapture)
{
var packet = Packet.ParsePacket(rawCapture.LinkLayerType, rawCapture.Data);
if (rawCapture.LinkLayerType == LinkLayers.Null)
{
packet = packet.PayloadPacket;
}
var statisticsRecord = new StatisticsRecord
{
Size = packet.TotalPacketLength,
CapturedAt = rawCapture.Timeval.Date
};
var discardStatistics = true;
while (packet != null && ConfigurationManager.GetInstance().IsPacketTypeMonitored(packet.GetType()))
{
discardStatistics = false;
ProtocolsLists.ProtocolParsersMapper[packet.GetType()].ParseProtocol(packet, statisticsRecord);
packet = packet.PayloadPacket;
}
if (discardStatistics)
{
statisticsRecord = null;
}
return(statisticsRecord);
}
private double GetIntervalFrom(StatisticsRecord record)
{
var percentage = (double)record.Errors / record.Cases;
var part = (int)(MathHelpers.CurrencyPrecision(percentage) / IntervalLength);
return(part * IntervalLength);
}
private void IncreaseStatistics(object adapter, StatisticsRecord capturedPacket)
{
NetworkAdapter networkAdapter = (NetworkAdapter)adapter;
lock (_statisticLock)
{
NetworkAdapterStatistics adapterStatistics = _networkAdaptersStatistics.FirstOrDefault(x => x.NetworkAdapter == networkAdapter);
if (adapterStatistics == null)
{
_networkAdaptersStatistics.Add(new NetworkAdapterStatistics()
{
NetworkAdapter = networkAdapter,
Statistics = new List <StatisticsRecord>()
{
capturedPacket
}
});
}
else
{
adapterStatistics.Statistics.Add(capturedPacket);
}
}
}
/// <summary>
/// Returns current stat record from <see cref="_statData"/>. It creates new record if necessary.
/// </summary>
/// <returns>Return current statistics record for provided <paramref name="subscription"/>.</returns>
private StatisticsRecord GetCurrentStatRecord(Subscription subscription)
{
var subscriptionId = subscription == null?_statSettings.GetSubscriptionSB() : new Guid(subscription.__PrimaryKey.ToString());
DateTime currentTimestampBucket = GetCurrentTimestampBucket();
Dictionary <Guid?, StatisticsRecord> bucketData;
if (!_statData.TryGetValue(currentTimestampBucket, out bucketData))
{
_statData[currentTimestampBucket] = bucketData = new Dictionary <Guid?, StatisticsRecord>();
}
StatisticsRecord statRecord;
if (!bucketData.TryGetValue(subscriptionId, out statRecord))
{
var statSetting = _statSettings.GetSetting(subscription) ?? _statSettings.CreateSetting(subscription);
bucketData[subscriptionId] = statRecord = new StatisticsRecord()
{
StatisticsSetting = statSetting,
StatisticsInterval = StatisticsInterval.OneSecond,
Since = currentTimestampBucket,
To = currentTimestampBucket.AddSeconds(1),
};
}
return(statRecord);
}
//return the score by data
//server with highest score will be choosen
private float?GetScore(string identifier, List <StatisticsRecord> records)
{
var config = _controller.StatisticsConfiguration;
float?score = null;
var averageRecord = new StatisticsRecord(identifier,
records.Where(record => record.MaxInboundSpeed != null).Select(record => record.MaxInboundSpeed.Value).ToList(),
records.Where(record => record.MaxOutboundSpeed != null).Select(record => record.MaxOutboundSpeed.Value).ToList(),
records.Where(record => record.AverageLatency != null).Select(record => record.AverageLatency.Value).ToList());
averageRecord.SetResponse(records.Select(record => record.AverageResponse).ToList());
foreach (var calculation in config.Calculations)
{
var name = calculation.Key;
var field = typeof(StatisticsRecord).GetField(name);
dynamic value = field?.GetValue(averageRecord);
var factor = calculation.Value;
if (value == null || factor.Equals(0))
{
continue;
}
score = score ?? 0;
score += value * factor;
}
if (score != null)
{
Logging.Debug($"Highest score: {score} {JsonConvert.SerializeObject(averageRecord, Formatting.Indented)}");
}
return(score);
}
private StatisticsRecord GetStatisticsByQueue(SubscriptionQueueEntry e, MessageStats prevStats)
{
var record = new StatisticsRecord();
var setting = _statisticsSettings.GetSetting(e.Subscription);
if (setting == null)
{
setting = _statisticsSettings.CreateSetting(e.Subscription);
}
record.StatisticsSetting = setting;
record.Since = DateTime.Now;
record.To = record.Since.AddMilliseconds(StatisticsIntervalToMilliseconds(Interval));
record.StatisticsInterval = Interval;
var stats = e.Queue.MessageStats;
var sumSentFunc = new Func <MessageStats, long> (x => x != null ? x.DeliverGet : 0);
var sumPublishFunc = new Func <MessageStats, long> (x => x != null ? x.Publish : 0);
if (stats != null)
{
record.SentCount = GetStatisticValue((int)sumSentFunc(stats), (int)sumSentFunc(prevStats));
record.ReceivedCount = GetStatisticValue((int)sumPublishFunc(stats), (int)sumPublishFunc(prevStats));
record.QueueLength = e.Queue.Messages;
}
return(record);
}
public void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
var ipPacket = (IPPacket)packet;
statisticsRecord.DestinationIpAddress = ipPacket.DestinationAddress.ToString();
statisticsRecord.SourceIpAddress = ipPacket.SourceAddress.ToString();
statisticsRecord.InternetLayer = ipPacket.GetType().Name.Replace("Packet", "");
}
public override void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
LogicalLayerControlPacket llcPacket = (LogicalLayerControlPacket)packet;
statisticsRecord.NetworkInterfaceLayer = llcPacket.IsSnap ? "Ieee802.3LLC+SNAP" : "Ieee802.3LLC";
TryParsePayloadIfEmpty(llcPacket);
}
public void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
var linuxSllPacket = (LinuxSllPacket)packet;
statisticsRecord.NetworkInterfaceLayer = linuxSllPacket.GetType().Name.Replace("Packet", "");
statisticsRecord.SourceMacAddress = new PhysicalAddress(linuxSllPacket.LinkLayerAddress).FormatMacAddress();
}
private void UpdateRecords()
{
var records = new Dictionary <string, StatisticsRecord>();
UpdateRecordsState state = new UpdateRecordsState();
int serverCount = _controller.GetCurrentConfiguration().configs.Count;
state.counter = serverCount;
bool isPing = Config.Ping;
for (int i = 0; i < serverCount; i++)
{
try
{
var server = _controller.GetCurrentConfiguration().configs[i];
var id = server.Identifier();
List <int> inboundSpeedRecords = null;
List <int> outboundSpeedRecords = null;
List <int> latencyRecords = null;
_inboundSpeedRecords.TryGetValue(id, out inboundSpeedRecords);
_outboundSpeedRecords.TryGetValue(id, out outboundSpeedRecords);
_latencyRecords.TryGetValue(id, out latencyRecords);
StatisticsRecord record = new StatisticsRecord(id, inboundSpeedRecords, outboundSpeedRecords, latencyRecords);
/* duplicate server identifier */
if (records.ContainsKey(id))
{
records[id] = record;
}
else
{
records.Add(id, record);
}
if (isPing)
{
// FIXME: on ping completed, every thing could be asynchrously changed.
// focus on: Config/ RawStatistics
MyPing ping = new MyPing(server, Repeat);
ping.Completed += ping_Completed;
ping.Start(new PingState {
state = state, record = record
});
}
else if (!record.IsEmptyData())
{
AppendRecord(id, record);
}
}
catch (Exception e)
{
Logging.Debug("config changed asynchrously, just ignore this server");
}
}
if (!isPing)
{
Save();
FilterRawStatistics();
}
}
public override void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
var tcpPacket = (TcpPacket)packet;
statisticsRecord.SourcePort = tcpPacket.SourcePort;
statisticsRecord.DestinationPort = tcpPacket.DestinationPort;
statisticsRecord.TransportLayer = tcpPacket.GetType().Name.Replace("Packet", "");
TryParsePayloadIfEmpty(tcpPacket);
}
public override void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
EthernetPacket ethernetPacket = (EthernetPacket)packet;
statisticsRecord.SourceMacAddress = ethernetPacket.SourceHardwareAddress.FormatMacAddress();
statisticsRecord.DestinationMacAddress = ethernetPacket.DestinationHardwareAddress.FormatMacAddress();
statisticsRecord.NetworkInterfaceLayer = ethernetPacket.GetType().Name.Replace("Packet", "");
TryParsePayloadIfEmpty(ethernetPacket);
}
private bool IsValidRecord(StatisticsRecord record)
{
if (Config.ByHourOfDay)
{
if (!record.Timestamp.Hour.Equals(DateTime.Now.Hour))
{
return(false);
}
}
return(true);
}
private void AppendRecord(string serverIdentifier, StatisticsRecord record)
{
List <StatisticsRecord> records;
if (!RawStatistics.TryGetValue(serverIdentifier, out records))
{
records = new List <StatisticsRecord>();
}
records.Add(record);
RawStatistics[serverIdentifier] = records;
}
public void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
var arpPacket = (ArpPacket)packet;
if (arpPacket.Operation == ArpOperation.ReplyReverse || arpPacket.Operation == ArpOperation.RequestReverse)
{
statisticsRecord.InternetLayer = "RARP";
}
else
{
statisticsRecord.InternetLayer = arpPacket.GetType().Name.Replace("Packet", "");
}
}
/// <summary>
/// Create a statistics record
/// The statistics record is almost entirely arrays so there was a choice to be made with regards to how this should be done
/// I chose to use array type in postgres. If you are a purist about relational concepts it would behove you to spit this into multiple tables
/// However I am laazy and this works for my purposes
/// </summary>
/// <param name="r"></param>
private void CreateStatistics(Product[] products, ref List <IRecord> recList, ref List <ulong> indexList)
{
//for each product
for (int x = 0; x < products.Length; x++)
{
//set integers
int a, b;
a = 0;
b = 1;
//for each unit in the arrays
for (int y = 0; y < products[x].stats.current.Length; y++)
{
//set val to reduce length of identifier
var val = products[x].stats;
//get longest array length
int len = GetLongestArrayProperty(val);
if (len == 0)
{
//if zero there is no additional dimension
//no values in two; could be malformed object
continue;
}
else
{
try {
//two dimensional arrays are flattened
StatisticsRecord statsRec = new StatisticsRecord(indexList[x], y, val.current?[y], val.avg?[y], val.avg30?[y], val.avg90?[y],
val.avg180?[y], val.atIntervalStart?[y], y, val.min[y]?.ElementAtOrDefault(a), val.min[y]?.ElementAtOrDefault(b), y, val.max[y]?.ElementAtOrDefault(a), val.max[y]?.ElementAt(b),
y, val.minInInterval[y]?.ElementAtOrDefault(a), val.minInInterval[y]?.ElementAtOrDefault(b),
y, val.maxInInterval[y]?.ElementAt(a), val.maxInInterval[y]?.ElementAt(b), val.outOfStockPercentageInInterval?[y],
val.outOfStockPercentage30?[y], val.outOfStockPercentage90?[y], val.lastOffersUpdate, val.totalOfferCount, val.lightningDealInfo?[y],
val.retrievedOfferCount, val.buyBoxPrice, val.buyBoxShipping, val.buyBoxIsUnqualified, val.buyBoxIsShippable, val.buyBoxIsPreorder,
val.buyBoxIsFBA, val.buyBoxIsAmazon, val.buyBoxIsMAP, val.buyBoxIsUsed, val.isAddonItem, val.sellerIdsLowestFBA?[y],
val.sellerIdsLowestFBM?[y], val.offerCountFBA, val.offerCountFBM);
//add stats record
recList.Add(statsRec);
}
catch (Exception e)
{
this._logger.Error("Filed to create: " + nameof(StatisticsRecord) + " with message: " + e.Message);
}
}
}
}
}
protected async void ProcessPacket(object networkAdapter, RawCapture rawCapture)
{
try
{
StatisticsRecord capturedPacket = rawCapture.ConvertToStatistics();
if (capturedPacket != null)
{
IncreaseStatistics(networkAdapter, capturedPacket);
}
}
catch (Exception e)
{
await KaTaLyzerLogger.Log(LogLevel.Error, e, new KeyValuePair <string, object>("CapturedData", rawCapture.Data));
}
}
private void UpdateRecords()
{
var records = new Dictionary <string, StatisticsRecord>();
UpdateRecordsState state = new UpdateRecordsState();
state.counter = _controller.GetCurrentConfiguration().configs.Count;
foreach (var server in _controller.GetCurrentConfiguration().configs)
{
var id = server.Identifier();
List <int> inboundSpeedRecords = null;
List <int> outboundSpeedRecords = null;
List <int> latencyRecords = null;
_inboundSpeedRecords.TryGetValue(id, out inboundSpeedRecords);
_outboundSpeedRecords.TryGetValue(id, out outboundSpeedRecords);
_latencyRecords.TryGetValue(id, out latencyRecords);
StatisticsRecord record = new StatisticsRecord(id, inboundSpeedRecords, outboundSpeedRecords, latencyRecords);
/* duplicate server identifier */
if (records.ContainsKey(id))
{
records[id] = record;
}
else
{
records.Add(id, record);
}
if (Config.Ping)
{
MyPing ping = new MyPing(server, Repeat);
ping.Completed += ping_Completed;
ping.Start(new PingState {
state = state, record = record
});
}
else if (!record.IsEmptyData())
{
AppendRecord(id, record);
}
}
if (!Config.Ping)
{
Save();
FilterRawStatistics();
}
}
private void ping_Completed(object sender, MyPing.CompletedEventArgs e)
{
PingState pingState = (PingState)e.UserState;
UpdateRecordsState state = pingState.state;
Server server = e.Server;
StatisticsRecord record = pingState.record;
record.SetResponse(e.RoundtripTime);
if (!record.IsEmptyData())
{
AppendRecord(server.Identifier(), record);
}
Logging.Debug($"Ping {server.FriendlyName()} {e.RoundtripTime.Count} times, {(100 - record.PackageLoss * 100)}% packages loss, min {record.MinResponse} ms, max {record.MaxResponse} ms, avg {record.AverageResponse} ms");
if (Interlocked.Decrement(ref state.counter) == 0)
{
Save();
FilterRawStatistics();
}
}
private void AppendRecord(string serverIdentifier, StatisticsRecord record)
{
try
{
List <StatisticsRecord> records;
lock (RawStatistics)
{
if (!RawStatistics.TryGetValue(serverIdentifier, out records))
{
records = new List <StatisticsRecord>();
RawStatistics[serverIdentifier] = records;
}
}
records.Add(record);
}
catch (Exception e)
{
Logging.LogUsefulException(e);
}
}
public Main()
{
InitializeComponent();
m_recordList = new List <Record>();
// initialize the data
m_setting = new Settings();
string filePath = m_setting.DBPath;
m_smartbufferlist = new RecordStructure(filePath);
m_diagnosisList = new StatisticsRecord();
m_currentRecord = new Record();
m_currentRecord.Date = DateTime.Today.ToShortDateString();
PreviousRecord.Enabled = false;
// update the data to today
this.calenderTimePicker.Value = DateTime.Today;
}
private async void UpdateRecords()
{
var records = new Dictionary <string, StatisticsRecord>();
foreach (var server in _controller.GetCurrentConfiguration().configs)
{
var id = server.Identifier();
List <int> inboundSpeedRecords = null;
List <int> outboundSpeedRecords = null;
List <int> latencyRecords = null;
_inboundSpeedRecords.TryGetValue(id, out inboundSpeedRecords);
_outboundSpeedRecords.TryGetValue(id, out outboundSpeedRecords);
_latencyRecords.TryGetValue(id, out latencyRecords);
StatisticsRecord record = new StatisticsRecord(id, inboundSpeedRecords, outboundSpeedRecords, latencyRecords);
/* duplicate server identifier */
if (records.ContainsKey(id))
{
records[id] = record;
}
else
{
records.Add(id, record);
}
}
if (Config.Ping)
{
var icmpResults = await TaskEx.WhenAll(_controller.GetCurrentConfiguration().configs.Select(ICMPTest));
foreach (var result in icmpResults.Where(result => result != null))
{
records[result.Server.Identifier()].SetResponse(result.RoundtripTime);
}
}
foreach (var kv in records.Where(kv => !kv.Value.IsEmptyData()))
{
AppendRecord(kv.Key, kv.Value);
}
}
private bool IsZerroStatistics(StatisticsRecord r)
{
return(r.SentCount == 0 && r.ReceivedCount == 0 && r.UniqueErrorsCount == 0);
}
public void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
var httpPacket = (HttpPacket)packet;
statisticsRecord.ApplicationLayer = httpPacket.GetType().Name.Replace("Packet", "");
}
public void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
var icmpV4Packet = (IcmpV4Packet)packet;
statisticsRecord.InternetLayer = icmpV4Packet.GetType().Name.Replace("Packet", "");
}
public void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
statisticsRecord.ApplicationLayer = "SSH";
}
public void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
Ieee8021QPacket vlanPacket = (Ieee8021QPacket)packet;
statisticsRecord.NetworkInterfaceLayer = "Ieee802.1Q";
}
public void ParseProtocol(Packet packet, StatisticsRecord statisticsRecord)
{
CdpPacket cdpPacket = (CdpPacket)packet;
statisticsRecord.NetworkInterfaceLayer = cdpPacket.GetType().Name.Replace("Packet", "");
}
public void TestPartCompression()
{
foreach (var dataService in DataServices)
{
// Arrange.
var statSetting = new StatisticsSetting();
var compressionSetting = new StatisticsCompressionSetting()
{
StatisticsSetting = statSetting,
CompressTo = StatisticsInterval.Hour,
StatisticsAgeCount = 1,
StatisticsAgeUnits = TimeUnit.Minute,
NextCompressTime = DateTime.Now,
};
var dataObjects = new DataObject[100];
var date = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour - 1, 0, 0, 0);
for (int i = 0; i < 100; i++)
{
dataObjects[i] = new StatisticsRecord()
{
Since = date.AddMinutes(i),
To = date.AddMinutes(i + 1),
StatisticsInterval = StatisticsInterval.OneMinute,
SentCount = 1,
StatisticsSetting = statSetting,
};
}
var counter = 0;
var mockTimeService = new Mock <IStatisticsTimeService>();
mockTimeService
.Setup(ts => ts.Now)
.Callback(() =>
{
counter++;
if (counter == 5)
{
throw new Exception("As if something went wrong.");
}
}).Returns(DateTime.Now);
dataService.UpdateObject(statSetting);
dataService.UpdateObject(compressionSetting);
dataService.UpdateObjects(ref dataObjects);
var component = new DefaultStatisticsCompressorService(
dataService,
mockTimeService.Object,
GetMockLogger(),
GetMockStatisticsService())
{
CompressionPeriod = 1000,
MaxRecordsForOneCompression = 50,
};
// Act.
Act(component);
// Assert.
var statRecords = dataService.Query <StatisticsRecord>(StatisticsRecord.Views.CompressView)
.OrderBy(r => r.Since)
.ToArray();
var compressedRecord = statRecords.First();
var unCompressedRecord = statRecords.Skip(1).First();
Assert.Equal(41, statRecords.Count());
Assert.Equal(60, compressedRecord.SentCount);
Assert.Equal(StatisticsInterval.Hour, compressedRecord.StatisticsInterval);
Assert.Equal(StatisticsInterval.OneMinute, unCompressedRecord.StatisticsInterval);
}
}
