mirror of
https://github.com/Xahau/xahaud.git
synced 2025-12-06 17:27:52 +00:00
328 lines
8.5 KiB
C++
328 lines
8.5 KiB
C++
|
|
#include "ValidationCollection.h"
|
|
|
|
#include <boost/foreach.hpp>
|
|
|
|
#include "Application.h"
|
|
#include "LedgerTiming.h"
|
|
#include "Log.h"
|
|
|
|
SETUP_LOG();
|
|
|
|
typedef std::map<uint160, SerializedValidation::pointer>::value_type u160_val_pair;
|
|
typedef boost::shared_ptr<ValidationSet> VSpointer;
|
|
|
|
void ValidationCollection::tune(int size, int age)
|
|
{
|
|
mValidations.setTargetSize(size);
|
|
mValidations.setTargetAge(age);
|
|
}
|
|
|
|
VSpointer ValidationCollection::findCreateSet(const uint256& ledgerHash)
|
|
{
|
|
VSpointer j = mValidations.fetch(ledgerHash);
|
|
if (!j)
|
|
{
|
|
j = boost::make_shared<ValidationSet>();
|
|
mValidations.canonicalize(ledgerHash, j);
|
|
}
|
|
return j;
|
|
}
|
|
|
|
VSpointer ValidationCollection::findSet(const uint256& ledgerHash)
|
|
{
|
|
return mValidations.fetch(ledgerHash);
|
|
}
|
|
|
|
bool ValidationCollection::addValidation(const SerializedValidation::pointer& val)
|
|
{
|
|
RippleAddress signer = val->getSignerPublic();
|
|
bool isCurrent = false;
|
|
if (theApp->getUNL().nodeInUNL(signer) || val->isTrusted())
|
|
{
|
|
val->setTrusted();
|
|
uint32 now = theApp->getOPs().getCloseTimeNC();
|
|
uint32 valClose = val->getSignTime();
|
|
if ((now > (valClose - LEDGER_EARLY_INTERVAL)) && (now < (valClose + LEDGER_VAL_INTERVAL)))
|
|
isCurrent = true;
|
|
else
|
|
{
|
|
cLog(lsWARNING) << "Received stale validation now=" << now << ", close=" << valClose;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cLog(lsINFO) << "Node " << signer.humanNodePublic() << " not in UNL";
|
|
}
|
|
|
|
uint256 hash = val->getLedgerHash();
|
|
uint160 node = signer.getNodeID();
|
|
|
|
{
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
if (!findCreateSet(hash)->insert(std::make_pair(node, val)).second)
|
|
return false;
|
|
if (isCurrent)
|
|
{
|
|
boost::unordered_map<uint160, SerializedValidation::pointer>::iterator it = mCurrentValidations.find(node);
|
|
if (it == mCurrentValidations.end())
|
|
mCurrentValidations.insert(std::make_pair(node, val));
|
|
else if (!it->second)
|
|
it->second = val;
|
|
else if (val->getSignTime() > it->second->getSignTime())
|
|
{
|
|
val->setPreviousHash(it->second->getLedgerHash());
|
|
mStaleValidations.push_back(it->second);
|
|
it->second = val;
|
|
condWrite();
|
|
}
|
|
}
|
|
}
|
|
|
|
cLog(lsINFO) << "Val for " << hash << " from " << signer.humanNodePublic()
|
|
<< " added " << (val->isTrusted() ? "trusted/" : "UNtrusted/") << (isCurrent ? "current" : "stale");
|
|
if (val->isTrusted())
|
|
theApp->getLedgerMaster().checkAccept(hash);
|
|
return isCurrent;
|
|
}
|
|
|
|
ValidationSet ValidationCollection::getValidations(const uint256& ledger)
|
|
{
|
|
{
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
VSpointer set = findSet(ledger);
|
|
if (set)
|
|
return ValidationSet(*set);
|
|
}
|
|
return ValidationSet();
|
|
}
|
|
|
|
void ValidationCollection::getValidationCount(const uint256& ledger, bool currentOnly, int& trusted, int &untrusted)
|
|
{
|
|
trusted = untrusted = 0;
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
VSpointer set = findSet(ledger);
|
|
if (set)
|
|
{
|
|
uint32 now = theApp->getOPs().getNetworkTimeNC();
|
|
BOOST_FOREACH(u160_val_pair& it, *set)
|
|
{
|
|
bool isTrusted = it.second->isTrusted();
|
|
if (isTrusted && currentOnly)
|
|
{
|
|
uint32 closeTime = it.second->getSignTime();
|
|
if ((now < (closeTime - LEDGER_EARLY_INTERVAL)) || (now > (closeTime + LEDGER_VAL_INTERVAL)))
|
|
isTrusted = false;
|
|
else
|
|
{
|
|
cLog(lsTRACE) << "VC: Untrusted due to time " << ledger;
|
|
}
|
|
}
|
|
if (isTrusted)
|
|
++trusted;
|
|
else
|
|
++untrusted;
|
|
}
|
|
}
|
|
cLog(lsTRACE) << "VC: " << ledger << "t:" << trusted << " u:" << untrusted;
|
|
}
|
|
|
|
void ValidationCollection::getValidationTypes(const uint256& ledger, int& full, int& partial)
|
|
{
|
|
full = partial = 0;
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
VSpointer set = findSet(ledger);
|
|
if (set)
|
|
{
|
|
BOOST_FOREACH(u160_val_pair& it, *set)
|
|
{
|
|
if (it.second->isTrusted())
|
|
{
|
|
if (it.second->isFull())
|
|
++full;
|
|
else
|
|
++partial;
|
|
}
|
|
}
|
|
}
|
|
cLog(lsTRACE) << "VC: " << ledger << "f:" << full << " p:" << partial;
|
|
}
|
|
|
|
|
|
int ValidationCollection::getTrustedValidationCount(const uint256& ledger)
|
|
{
|
|
int trusted = 0;
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
VSpointer set = findSet(ledger);
|
|
if (set)
|
|
{
|
|
BOOST_FOREACH(u160_val_pair& it, *set)
|
|
{
|
|
if (it.second->isTrusted())
|
|
++trusted;
|
|
}
|
|
}
|
|
return trusted;
|
|
}
|
|
|
|
int ValidationCollection::getNodesAfter(const uint256& ledger)
|
|
{ // Number of trusted nodes that have moved past this ledger
|
|
int count = 0;
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
BOOST_FOREACH(u160_val_pair& it, mCurrentValidations)
|
|
{
|
|
if (it.second->isTrusted() && it.second->isPreviousHash(ledger))
|
|
++count;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
int ValidationCollection::getLoadRatio(bool overLoaded)
|
|
{ // how many trusted nodes are able to keep up, higher is better
|
|
int goodNodes = overLoaded ? 1 : 0;
|
|
int badNodes = overLoaded ? 0 : 1;
|
|
{
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
BOOST_FOREACH(u160_val_pair& it, mCurrentValidations)
|
|
{
|
|
if (it.second->isTrusted())
|
|
{
|
|
if (it.second->isFull())
|
|
++goodNodes;
|
|
else
|
|
++badNodes;
|
|
}
|
|
}
|
|
}
|
|
return (goodNodes * 100) / (goodNodes + badNodes);
|
|
}
|
|
|
|
std::list<SerializedValidation::pointer> ValidationCollection::getCurrentTrustedValidations()
|
|
{
|
|
uint32 cutoff = theApp->getOPs().getNetworkTimeNC() - LEDGER_VAL_INTERVAL;
|
|
|
|
std::list<SerializedValidation::pointer> ret;
|
|
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
boost::unordered_map<uint160, SerializedValidation::pointer>::iterator it = mCurrentValidations.begin();
|
|
while (it != mCurrentValidations.end())
|
|
{
|
|
if (!it->second) // contains no record
|
|
it = mCurrentValidations.erase(it);
|
|
else if (it->second->getSignTime() < cutoff)
|
|
{ // contains a stale record
|
|
mStaleValidations.push_back(it->second);
|
|
it->second.reset();
|
|
condWrite();
|
|
it = mCurrentValidations.erase(it);
|
|
}
|
|
else
|
|
{ // contains a live record
|
|
if (it->second->isTrusted())
|
|
ret.push_back(it->second);
|
|
++it;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
boost::unordered_map<uint256, currentValidationCount>
|
|
ValidationCollection::getCurrentValidations(uint256 currentLedger)
|
|
{
|
|
uint32 cutoff = theApp->getOPs().getNetworkTimeNC() - LEDGER_VAL_INTERVAL;
|
|
bool valCurrentLedger = currentLedger.isNonZero();
|
|
|
|
boost::unordered_map<uint256, currentValidationCount> ret;
|
|
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
boost::unordered_map<uint160, SerializedValidation::pointer>::iterator it = mCurrentValidations.begin();
|
|
while (it != mCurrentValidations.end())
|
|
{
|
|
if (!it->second) // contains no record
|
|
it = mCurrentValidations.erase(it);
|
|
else if (it->second->getSignTime() < cutoff)
|
|
{ // contains a stale record
|
|
mStaleValidations.push_back(it->second);
|
|
it->second.reset();
|
|
condWrite();
|
|
it = mCurrentValidations.erase(it);
|
|
}
|
|
else
|
|
{ // contains a live record
|
|
bool countPreferred = valCurrentLedger && it->second->isPreviousHash(currentLedger);
|
|
currentValidationCount& p = countPreferred ? ret[currentLedger] : ret[it->second->getLedgerHash()];
|
|
|
|
++(p.first); // count for the favored ledger
|
|
uint160 ni = it->second->getNodeID();
|
|
if (ni > p.second)
|
|
p.second = ni;
|
|
++it;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void ValidationCollection::flush()
|
|
{
|
|
bool anyNew = false;
|
|
|
|
cLog(lsINFO) << "Flushing validations";
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
BOOST_FOREACH(u160_val_pair& it, mCurrentValidations)
|
|
{
|
|
if (it.second)
|
|
mStaleValidations.push_back(it.second);
|
|
anyNew = true;
|
|
}
|
|
mCurrentValidations.clear();
|
|
if (anyNew)
|
|
condWrite();
|
|
while (mWriting)
|
|
{
|
|
sl.unlock();
|
|
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
|
|
sl.lock();
|
|
}
|
|
cLog(lsDEBUG) << "Validations flushed";
|
|
}
|
|
|
|
void ValidationCollection::condWrite()
|
|
{
|
|
if (mWriting)
|
|
return;
|
|
mWriting = true;
|
|
boost::thread thread(boost::bind(&ValidationCollection::doWrite, this));
|
|
thread.detach();
|
|
}
|
|
|
|
void ValidationCollection::doWrite()
|
|
{
|
|
LoadEvent::autoptr event(theApp->getJobQueue().getLoadEventAP(jtDISK));
|
|
static boost::format insVal("INSERT INTO LedgerValidations "
|
|
"(LedgerHash,NodePubKey,Flags,SignTime,Signature) VALUES ('%s','%s','%u','%u',%s);");
|
|
|
|
boost::mutex::scoped_lock sl(mValidationLock);
|
|
assert(mWriting);
|
|
while (!mStaleValidations.empty())
|
|
{
|
|
std::vector<SerializedValidation::pointer> vector;
|
|
mStaleValidations.swap(vector);
|
|
sl.unlock();
|
|
{
|
|
Database *db = theApp->getLedgerDB()->getDB();
|
|
ScopedLock dbl(theApp->getLedgerDB()->getDBLock());
|
|
|
|
db->executeSQL("BEGIN TRANSACTION;");
|
|
BOOST_FOREACH(const SerializedValidation::pointer& it, vector)
|
|
db->executeSQL(boost::str(insVal % it->getLedgerHash().GetHex()
|
|
% it->getSignerPublic().humanNodePublic() % it->getFlags() % it->getSignTime()
|
|
% sqlEscape(it->getSignature())));
|
|
db->executeSQL("END TRANSACTION;");
|
|
}
|
|
sl.lock();
|
|
}
|
|
mWriting = false;
|
|
}
|