/// <summary>
/// Process Network Fragments and summarize into ProcessedFragmentsModel
/// </summary>
/// <param name="jsonContent"></param>
/// <returns></returns>
public Task <ProcessedNetworkStatisticsModel> ProcessNetworkStatistics(string jsonContent)
{
Exceptions.ThrowIfNotJson(jsonContent, "jsonContent");
var networkStats = JsonConvert.DeserializeObject <List <NetworkStatisticsModel> >(jsonContent);
var lastBlockReceivedAt = networkStats.Max(x => x.LastBlockReceived).HasValue ? networkStats.Max(x => x.LastBlockReceived).Value : default;
var lastFragmentReceivedAt = networkStats.Max(x => x.LastFragmentReceived).HasValue ? networkStats.Max(x => x.LastFragmentReceived).Value : default;
var lastGossipReceivedAt = networkStats.Max(x => x.LastGossipReceived).HasValue ? networkStats.Max(x => x.LastGossipReceived).Value : default;
var blocksReceivedInPast30Min = networkStats.Where(x => x.LastBlockReceived > DateTimeOffset.UtcNow.AddMinutes(-30)).Count();
var fragmentsReceivedInPast30Min = networkStats.Where(x => x.LastFragmentReceived > DateTimeOffset.UtcNow.AddMinutes(-30)).Count();
var gossipReceivedInPast30Min = networkStats.Where(x => x.LastGossipReceived > DateTimeOffset.UtcNow.AddMinutes(-30)).Count();
var result = new ProcessedNetworkStatisticsModel()
{
Timestamp = DateTimeOffset.UtcNow,
TotalEstablishedConnections = networkStats.Count(),
LastBlockReceivedAt = lastBlockReceivedAt,
LastFragmentReceivedAt = lastFragmentReceivedAt,
LastGossipReceivedAt = lastGossipReceivedAt,
BlocksReceivedInPast30Min = blocksReceivedInPast30Min,
FragmentsReceivedInPast30Min = fragmentsReceivedInPast30Min,
GossipReceivedInPast30Min = gossipReceivedInPast30Min
};
_database.NetworkStatistics.Add(result);
_database.SaveChanges();
return(Task.FromResult(result));
}
/// <summary>
///
/// </summary>
/// <param name="jsonContent"></param>
/// <returns></returns>
public Task <StoredSettingsModel> ProcessSettings(string jsonContent)
{
Exceptions.ThrowIfNotJson(jsonContent, "jsonContent");
var result = JsonConvert.DeserializeObject <ProcessedSettingsModel>(jsonContent);
result.Timestamp = DateTimeOffset.UtcNow;
//query last settings, if changed save the new settings to the DB
var settings = GetCurrentSettings();
if (result.CompareTo(settings) > 0)
{
_database.Settings.Add(new StoredSettingsModel
{
Timestamp = result.Timestamp,
Block0Hash = result.Block0Hash,
Block0Time = result.Block0Time,
ConsensusVersion = result.ConsensusVersion,
CurrSlotStartTime = result.CurrSlotStartTime,
Certificate = result.Fees.Certificate,
Coefficient = result.Fees.Coefficient,
Constant = result.Fees.Constant,
MaxTxsPerBlock = result.MaxTxsPerBlock,
SlotDuration = result.SlotDuration,
SlotsPerEpoch = result.SlotsPerEpoch
});
_database.SaveChanges();
}
return(Task.FromResult(GetCurrentSettings()));
}
/// <summary>
///
/// </summary>
/// <param name="logLine"></param>
/// <param name="lineNumber"></param>
/// <returns></returns>
public Task IngestLogEntry(string logLine, int lineNumber)
{
Exceptions.ThrowIfNotJson(logLine, "logLine");
Exceptions.ThrowIfNegative(lineNumber, "lineNumber");
var logEntry = JsonConvert.DeserializeObject <LogIngestionModel>(logLine);
_db.LogEntries.Add(logEntry);
_db.SaveChanges();
return(Task.FromResult(true));
}
/// <summary>
///
/// </summary>
/// <param name="jsonContent"></param>
/// <returns></returns>
public Task <ProcessedStakeModel> ProcessStake(string jsonContent)
{
Exceptions.ThrowIfNotJson(jsonContent, "jsonContent");
var poolDistibution = new List <PoolDistribution>();
var stakeModel = JsonConvert.DeserializeObject <StakeModel>(jsonContent);
var pools = (JArray)stakeModel.Stake.Pools;
foreach (var pool in pools)
{
var distro = new PoolDistribution();
foreach (var detail in pool)
{
var t = detail.Type;
if (detail.Type.Equals(JTokenType.String))
{
distro.PoolId = (string)detail;
}
else
{
distro.AdaStaked = (long)detail;
}
}
poolDistibution.Add(distro);
}
//// SQLite can't map IEnum or dynamic objects, so convert pooldistribtion list back to json to store
var poolDistributionJson = JsonConvert.SerializeObject(poolDistibution, Formatting.None);
var result = new ProcessedStakeModel()
{
Timestamp = DateTimeOffset.UtcNow,
Epoch = stakeModel.Epoch,
Dangling = stakeModel.Stake.Dangling,
Unassigned = stakeModel.Stake.Unassigned,
PoolDistributionJson = poolDistributionJson
};
_database.StakeDistribution.Add(result);
_database.SaveChanges();
// return ProcessedFragmentsModel result
return(Task.FromResult(result));
}
/// <summary>
/// Process Network statistics and summarize into ProcessedNodeStatisticsModel
/// </summary>
/// <param name="jsonContent"></param>
/// <returns>ProcessedNodeStatisticsModel</returns>
public Task <NodeStatisticsModel> ProcessNodeStatistics(string jsonContent)
{
Exceptions.ThrowIfNotJson(jsonContent, "jsonContent");
var nodeStats = JsonConvert.DeserializeObject <NodeStatisticsModel>(jsonContent);
if (!nodeStats.LastBlockTime.HasValue)
{
nodeStats.LastBlockTime = _opts.ApplicationStartedOn;
}
nodeStats.Timestamp = DateTimeOffset.UtcNow;
if (!string.IsNullOrEmpty(nodeStats.LastBlockDate) && nodeStats.LastBlockTime.HasValue)
{
_database.NodeStatisticEntries.Add(nodeStats);
_database.SaveChanges();
}
return(Task.FromResult(nodeStats));
}
/// <summary>
/// Process Network Fragments and summarize into ProcessedFragmentsModel
/// </summary>
/// <param name="jsonContent"></param>
/// <returns></returns>
public Task <ProcessedFragmentsModel> ProcessFragments(string jsonContent)
{
Exceptions.ThrowIfNotJson(jsonContent, "jsonContent");
var fragments = JsonConvert.DeserializeObject <List <FragmentModel> >(jsonContent).ToList();
var restFragments = fragments.Where(fragment => fragment.Received_from.Equals("Rest"));
var networkFragments = fragments.Where(fragment => fragment.Received_from.Equals("Network"));
List <FragmentModel> unknownFragments = new List <FragmentModel>();
List <PendingFragmentModel> pendingFragments = new List <PendingFragmentModel>();
List <InBlockFragmentModel> inBlockFragments = new List <InBlockFragmentModel>();
List <RejectedFragmentModel> rejectedFragments = new List <RejectedFragmentModel>();
foreach (var fragment in fragments)
{
var statusType = fragment.Status.GetType();
if (statusType == typeof(string))
{
pendingFragments.Add(
new PendingFragmentModel
{
Fragment_id = fragment.Fragment_id,
Last_updated_at = fragment.Last_updated_at,
Received_at = fragment.Received_at,
Received_from = fragment.Received_from,
Status = (string)fragment.Status
});
continue;
}
if (statusType == typeof(JObject))
{
var json = fragment.Status.ToString(Formatting.None);
var blockStatus = JsonConvert.DeserializeObject <InABlockStatus>(json);
var rejectedStatus = JsonConvert.DeserializeObject <RejectedStatus>(json);
if (blockStatus.InABlock != null)
{
inBlockFragments.Add(
new InBlockFragmentModel
{
Fragment_id = fragment.Fragment_id,
Last_updated_at = fragment.Last_updated_at,
Received_at = fragment.Received_at,
Received_from = fragment.Received_from,
Status = blockStatus.InABlock
});
}
else
{
if (rejectedStatus.Rejected != null)
{
rejectedFragments.Add(
new RejectedFragmentModel
{
Fragment_id = fragment.Fragment_id,
Last_updated_at = fragment.Last_updated_at,
Received_at = fragment.Received_at,
Received_from = fragment.Received_from,
Status = rejectedStatus.Rejected
});
}
else
{
unknownFragments.Add(fragment);
}
}
}
}
var totalFragments = fragments.Count();
var fragmentsReceviedFromRest = restFragments.Count();
var fragmentsReceviedFromNetwork = networkFragments.Count();
var fragmentsInBlock = inBlockFragments.Count();
var fragmentsRejected = rejectedFragments.Count();
var fragmentsPending = pendingFragments.Count();
var result = new ProcessedFragmentsModel()
{
Timestamp = DateTimeOffset.UtcNow,
TotalFragments = totalFragments,
FragmentsReceviedFromRest = fragmentsReceviedFromRest,
RestFragments = restFragments,
FragmentsReceviedFromNetwork = fragmentsReceviedFromNetwork,
NetworkFragments = networkFragments,
FragmentsInBlock = fragmentsInBlock,
FragmentsRejected = fragmentsRejected,
BlockFragments = inBlockFragments,
FragmentsPending = fragmentsPending,
PendingFragments = pendingFragments
};
// SQL Lite can't map IEnum or dynamic objects, so trim to just the aggregate counts
_database.FragmentStatistics.Add(new StoredFragmentsModel
{
Timestamp = result.Timestamp,
TotalFragments = result.TotalFragments,
FragmentsReceviedFromRest = result.FragmentsReceviedFromRest,
FragmentsReceviedFromNetwork = result.FragmentsReceviedFromNetwork,
FragmentsInBlock = result.FragmentsInBlock,
FragmentsRejected = result.FragmentsRejected,
FragmentsPending = result.FragmentsPending,
});
_database.SaveChanges();
// return ProcessedFragmentsModel result
return(Task.FromResult(result));
}
public Task <ProcessedLeadersLogsModel> ProcessLeadersLogs(string jsonContent)
{
Exceptions.ThrowIfNotJson(jsonContent, "jsonContent");
var leadersLogs = JsonConvert.DeserializeObject <List <LeadersLogsModel> >(jsonContent);
var parsedLeadersLogs = new List <StoredLeadersLogsModel>();
foreach (var leaderlog in leadersLogs)
{
var statusType = leaderlog.Status.GetType();
if (statusType == typeof(string))
{
parsedLeadersLogs.Add(
new StoredLeadersLogsModel
{
Created_at_time = leaderlog.Created_at_time,
Enclave_leader_id = leaderlog.Enclave_leader_id,
Scheduled_at_date = leaderlog.Scheduled_at_date,
Finished_at_time = leaderlog.Finished_at_time,
Scheduled_at_time = leaderlog.Scheduled_at_time,
Status = (string)leaderlog.Status,
Block = null,
Chain_length = null,
Wake_at_time = leaderlog.Wake_at_time
});
continue;
}
if (statusType == typeof(JObject))
{
var json = leaderlog.Status.ToString(Formatting.None);
BlockStatus blockStatus = JsonConvert.DeserializeObject <BlockStatus>(json);
if (blockStatus.Block != null)
{
parsedLeadersLogs.Add(
new StoredLeadersLogsModel
{
Created_at_time = leaderlog.Created_at_time,
Enclave_leader_id = leaderlog.Enclave_leader_id,
Scheduled_at_date = leaderlog.Scheduled_at_date,
Finished_at_time = leaderlog.Finished_at_time,
Scheduled_at_time = leaderlog.Scheduled_at_time,
Status = "Block",
Block = blockStatus.Block.Block,
Chain_length = blockStatus.Block.Chain_length,
Wake_at_time = leaderlog.Wake_at_time
});
}
}
}
var result = new ProcessedLeadersLogsModel()
{
Timestamp = DateTimeOffset.UtcNow,
LeadersLogsJson = JsonConvert.SerializeObject(parsedLeadersLogs, Formatting.None)
};
// SQL Lite can't map IEnum or dynamic objects, so store as json
_database.LeadersLogs.Add(result);
_database.SaveChanges();
// return ProcessedFragmentsModel result
return(Task.FromResult(result));
}