ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2025-12-06 17:27:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add ledger remove from acquire set. Cleanups.

Browse Source
This commit is contained in:
JoelKatz
2012-05-04 03:33:37 -07:00
parent 8bf477acac
commit d29733aa11
2 changed files with 67 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
src/LedgerAcquire.cpp
View File

@@ -16,11 +16,11 @@ void LedgerAcquire::done()
std::vector< boost::function<void (LedgerAcquire::pointer)> > triggers; std::vector< boost::function<void (LedgerAcquire::pointer)> > triggers;
mLock.lock(); mLock.lock();
triggers=mOnComplete; triggers = mOnComplete;
mOnComplete.empty(); mOnComplete.empty();
mLock.unlock(); mLock.unlock();
for(int i=0; i<triggers.size(); i++) for (int i = 0; i<triggers.size(); ++i)
triggers[i](shared_from_this()); triggers[i](shared_from_this());
} }
@@ -31,8 +31,8 @@ void LedgerAcquire::setTimer()
void LedgerAcquire::timerEntry(boost::weak_ptr<LedgerAcquire> wptr) void LedgerAcquire::timerEntry(boost::weak_ptr<LedgerAcquire> wptr)
{ {
LedgerAcquire::pointer ptr=wptr.lock(); LedgerAcquire::pointer ptr = wptr.lock();
if(ptr) ptr->trigger(true); if (ptr) ptr->trigger(true);
} }
void LedgerAcquire::addOnComplete(boost::function<void (LedgerAcquire::pointer)> trigger) void LedgerAcquire::addOnComplete(boost::function<void (LedgerAcquire::pointer)> trigger)
@@ -44,27 +44,27 @@ void LedgerAcquire::addOnComplete(boost::function<void (LedgerAcquire::pointer)>
void LedgerAcquire::trigger(bool timer) void LedgerAcquire::trigger(bool timer)
{ {
if(mComplete || mFailed) return; if (mComplete || mFailed) return;
if(!mHaveBase) if (!mHaveBase)
{ {
// WRITEME: Do we need to search for peers? // WRITEME: Do we need to search for peers?
boost::shared_ptr<newcoin::TMGetLedger> tmGL=boost::make_shared<newcoin::TMGetLedger>(); boost::shared_ptr<newcoin::TMGetLedger> tmGL = boost::make_shared<newcoin::TMGetLedger>();
tmGL->set_ledgerhash(mHash.begin(), mHash.size()); tmGL->set_ledgerhash(mHash.begin(), mHash.size());
tmGL->set_itype(newcoin::liBASE); tmGL->set_itype(newcoin::liBASE);
sendRequest(tmGL); sendRequest(tmGL);
} }
if(mHaveBase && !mHaveTransactions) if (mHaveBase && !mHaveTransactions)
{ {
assert(mLedger); assert(mLedger);
if(mLedger->peekTransactionMap()->getHash().isZero()) if (mLedger->peekTransactionMap()->getHash().isZero())
{ // we need the root node { // we need the root node
boost::shared_ptr<newcoin::TMGetLedger> tmGL=boost::make_shared<newcoin::TMGetLedger>(); boost::shared_ptr<newcoin::TMGetLedger> tmGL = boost::make_shared<newcoin::TMGetLedger>();
tmGL->set_ledgerhash(mHash.begin(), mHash.size()); tmGL->set_ledgerhash(mHash.begin(), mHash.size());
tmGL->set_ledgerseq(mLedger->getLedgerSeq()); tmGL->set_ledgerseq(mLedger->getLedgerSeq());
tmGL->set_itype(newcoin::liTX_NODE); tmGL->set_itype(newcoin::liTX_NODE);
*(tmGL->add_nodeids())=SHAMapNode().getRawString(); *(tmGL->add_nodeids()) = SHAMapNode().getRawString();
sendRequest(tmGL); sendRequest(tmGL);
} }
else else
@@ -72,38 +72,38 @@ void LedgerAcquire::trigger(bool timer)
std::vector<SHAMapNode> nodeIDs; std::vector<SHAMapNode> nodeIDs;
std::vector<uint256> nodeHashes; std::vector<uint256> nodeHashes;
mLedger->peekTransactionMap()->getMissingNodes(nodeIDs, nodeHashes, 128); mLedger->peekTransactionMap()->getMissingNodes(nodeIDs, nodeHashes, 128);
if(nodeIDs.empty()) if (nodeIDs.empty())
{ {
if(!mLedger->peekTransactionMap()->isValid()) mFailed=true; if (!mLedger->peekTransactionMap()->isValid()) mFailed = true;
else else
{ {
mHaveTransactions=true; mHaveTransactions = true;
if(mHaveState) mComplete=true; if (mHaveState) mComplete = true;
} }
} }
else else
{ {
boost::shared_ptr<newcoin::TMGetLedger> tmGL=boost::make_shared<newcoin::TMGetLedger>(); boost::shared_ptr<newcoin::TMGetLedger> tmGL = boost::make_shared<newcoin::TMGetLedger>();
tmGL->set_ledgerhash(mHash.begin(), mHash.size()); tmGL->set_ledgerhash(mHash.begin(), mHash.size());
tmGL->set_ledgerseq(mLedger->getLedgerSeq()); tmGL->set_ledgerseq(mLedger->getLedgerSeq());
tmGL->set_itype(newcoin::liTX_NODE); tmGL->set_itype(newcoin::liTX_NODE);
for(std::vector<SHAMapNode>::iterator it=nodeIDs.begin(); it!=nodeIDs.end(); ++it) for (std::vector<SHAMapNode>::iterator it = nodeIDs.begin(); it != nodeIDs.end(); ++it)
*(tmGL->add_nodeids())=it->getRawString(); *(tmGL->add_nodeids()) = it->getRawString();
sendRequest(tmGL); sendRequest(tmGL);
} }
} }
} }
if(mHaveBase && !mHaveState) if (mHaveBase && !mHaveState)
{ {
assert(mLedger); assert(mLedger);
if(mLedger->peekAccountStateMap()->getHash().isZero()) if (mLedger->peekAccountStateMap()->getHash().isZero())
{ // we need the root node { // we need the root node
boost::shared_ptr<newcoin::TMGetLedger> tmGL=boost::make_shared<newcoin::TMGetLedger>(); boost::shared_ptr<newcoin::TMGetLedger> tmGL = boost::make_shared<newcoin::TMGetLedger>();
tmGL->set_ledgerhash(mHash.begin(), mHash.size()); tmGL->set_ledgerhash(mHash.begin(), mHash.size());
tmGL->set_ledgerseq(mLedger->getLedgerSeq()); tmGL->set_ledgerseq(mLedger->getLedgerSeq());
tmGL->set_itype(newcoin::liAS_NODE); tmGL->set_itype(newcoin::liAS_NODE);
*(tmGL->add_nodeids())=SHAMapNode().getRawString(); *(tmGL->add_nodeids()) = SHAMapNode().getRawString();
sendRequest(tmGL); sendRequest(tmGL);
} }
else else
@@ -111,45 +111,45 @@ void LedgerAcquire::trigger(bool timer)
std::vector<SHAMapNode> nodeIDs; std::vector<SHAMapNode> nodeIDs;
std::vector<uint256> nodeHashes; std::vector<uint256> nodeHashes;
mLedger->peekAccountStateMap()->getMissingNodes(nodeIDs, nodeHashes, 128); mLedger->peekAccountStateMap()->getMissingNodes(nodeIDs, nodeHashes, 128);
if(nodeIDs.empty()) if (nodeIDs.empty())
{ {
if(!mLedger->peekAccountStateMap()->isValid()) mFailed=true; if (!mLedger->peekAccountStateMap()->isValid()) mFailed = true;
else else
{ {
mHaveState=true; mHaveState = true;
if(mHaveTransactions) mComplete=true; if (mHaveTransactions) mComplete = true;
} }
} }
else else
{ {
boost::shared_ptr<newcoin::TMGetLedger> tmGL=boost::make_shared<newcoin::TMGetLedger>(); boost::shared_ptr<newcoin::TMGetLedger> tmGL = boost::make_shared<newcoin::TMGetLedger>();
tmGL->set_ledgerhash(mHash.begin(), mHash.size()); tmGL->set_ledgerhash(mHash.begin(), mHash.size());
tmGL->set_ledgerseq(mLedger->getLedgerSeq()); tmGL->set_ledgerseq(mLedger->getLedgerSeq());
tmGL->set_itype(newcoin::liAS_NODE); tmGL->set_itype(newcoin::liAS_NODE);
for(std::vector<SHAMapNode>::iterator it=nodeIDs.begin(); it!=nodeIDs.end(); ++it) for (std::vector<SHAMapNode>::iterator it =nodeIDs.begin(); it != nodeIDs.end(); ++it)
*(tmGL->add_nodeids())=it->getRawString(); *(tmGL->add_nodeids()) = it->getRawString();
sendRequest(tmGL); sendRequest(tmGL);
} }
} }
} }
if(mComplete || mFailed) if (mComplete || mFailed)
done(); done();
else if(timer) else if (timer)
setTimer(); setTimer();
} }
void LedgerAcquire::sendRequest(boost::shared_ptr<newcoin::TMGetLedger> tmGL) void LedgerAcquire::sendRequest(boost::shared_ptr<newcoin::TMGetLedger> tmGL)
{ {
boost::recursive_mutex::scoped_lock sl(mLock); boost::recursive_mutex::scoped_lock sl(mLock);
if(mPeers.empty()) return; if (mPeers.empty()) return;
PackedMessage::pointer packet=boost::make_shared<PackedMessage>(tmGL, newcoin::mtGET_LEDGER); PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tmGL, newcoin::mtGET_LEDGER);
std::list<boost::weak_ptr<Peer> >::iterator it=mPeers.begin(); std::list<boost::weak_ptr<Peer> >::iterator it = mPeers.begin();
while(it!=mPeers.end()) while(it!=mPeers.end())
{ {
if(it->expired()) if (it->expired())
mPeers.erase(it++); mPeers.erase(it++);
else else
{ {
@@ -167,11 +167,11 @@ void LedgerAcquire::peerHas(Peer::pointer ptr)
while(it!=mPeers.end()) while(it!=mPeers.end())
{ {
Peer::pointer pr=it->lock(); Peer::pointer pr=it->lock();
if(!pr) // we have a dead entry, remove it if (!pr) // we have a dead entry, remove it
it=mPeers.erase(it); it=mPeers.erase(it);
else else
{ {
if(pr->samePeer(ptr)) return; // we already have this peer if (pr->samePeer(ptr)) return; // we already have this peer
++it; ++it;
} }
} }
@@ -185,11 +185,11 @@ void LedgerAcquire::badPeer(Peer::pointer ptr)
while(it!=mPeers.end()) while(it!=mPeers.end())
{ {
Peer::pointer pr=it->lock(); Peer::pointer pr=it->lock();
if(!pr) // we have a dead entry, remove it if (!pr) // we have a dead entry, remove it
it=mPeers.erase(it); it=mPeers.erase(it);
else else
{ {
if(ptr->samePeer(pr)) if (ptr->samePeer(pr))
{ // We found a pointer to the bad peer { // We found a pointer to the bad peer
mPeers.erase(it); mPeers.erase(it);
return; return;
@@ -202,9 +202,9 @@ void LedgerAcquire::badPeer(Peer::pointer ptr)
bool LedgerAcquire::takeBase(const std::string& data) bool LedgerAcquire::takeBase(const std::string& data)
{ // Return value: true=normal, false=bad data { // Return value: true=normal, false=bad data
boost::recursive_mutex::scoped_lock sl(mLock); boost::recursive_mutex::scoped_lock sl(mLock);
if(mHaveBase) return true; if (mHaveBase) return true;
Ledger* ledger=new Ledger(data); Ledger* ledger=new Ledger(data);
if(ledger->getHash()!=mHash) if (ledger->getHash()!=mHash)
{ {
delete ledger; delete ledger;
return false; return false;
@@ -218,34 +218,34 @@ bool LedgerAcquire::takeBase(const std::string& data)
bool LedgerAcquire::takeTxNode(const std::list<SHAMapNode>& nodeIDs, bool LedgerAcquire::takeTxNode(const std::list<SHAMapNode>& nodeIDs,
const std::list<std::vector<unsigned char> >& data) const std::list<std::vector<unsigned char> >& data)
{ {
if(!mHaveBase) return false; if (!mHaveBase) return false;
std::list<SHAMapNode>::const_iterator nodeIDit=nodeIDs.begin(); std::list<SHAMapNode>::const_iterator nodeIDit=nodeIDs.begin();
std::list<std::vector<unsigned char> >::const_iterator nodeDatait=data.begin(); std::list<std::vector<unsigned char> >::const_iterator nodeDatait=data.begin();
while(nodeIDit!=nodeIDs.end()) while(nodeIDit!=nodeIDs.end())
{ {
if(!mLedger->peekTransactionMap()->addKnownNode(*nodeIDit, *nodeDatait)) if (!mLedger->peekTransactionMap()->addKnownNode(*nodeIDit, *nodeDatait))
return false; return false;
++nodeIDit; ++nodeIDit;
++nodeDatait; ++nodeDatait;
} }
if(!mLedger->peekTransactionMap()->isSynching()) mHaveTransactions=true; if (!mLedger->peekTransactionMap()->isSynching()) mHaveTransactions=true;
return true; return true;
} }
bool LedgerAcquire::takeAsNode(const std::list<SHAMapNode>& nodeIDs, bool LedgerAcquire::takeAsNode(const std::list<SHAMapNode>& nodeIDs,
const std::list<std::vector<unsigned char> >& data) const std::list<std::vector<unsigned char> >& data)
{ {
if(!mHaveBase) return false; if (!mHaveBase) return false;
std::list<SHAMapNode>::const_iterator nodeIDit=nodeIDs.begin(); std::list<SHAMapNode>::const_iterator nodeIDit=nodeIDs.begin();
std::list<std::vector<unsigned char> >::const_iterator nodeDatait=data.begin(); std::list<std::vector<unsigned char> >::const_iterator nodeDatait=data.begin();
while(nodeIDit!=nodeIDs.end()) while(nodeIDit!=nodeIDs.end())
{ {
if(!mLedger->peekAccountStateMap()->addKnownNode(*nodeIDit, *nodeDatait)) if (!mLedger->peekAccountStateMap()->addKnownNode(*nodeIDit, *nodeDatait))
return false; return false;
++nodeIDit; ++nodeIDit;
++nodeDatait; ++nodeDatait;
} }
if(!mLedger->peekAccountStateMap()->isSynching()) mHaveState=true; if (!mLedger->peekAccountStateMap()->isSynching()) mHaveState=true;
return true; return true;
} }
@@ -253,7 +253,7 @@ LedgerAcquire::pointer LedgerAcquireMaster::findCreate(const uint256& hash)
{ {
boost::mutex::scoped_lock sl(mLock); boost::mutex::scoped_lock sl(mLock);
LedgerAcquire::pointer& ptr=mLedgers[hash]; LedgerAcquire::pointer& ptr=mLedgers[hash];
if(ptr) return ptr; if (ptr) return ptr;
return boost::make_shared<LedgerAcquire>(hash); return boost::make_shared<LedgerAcquire>(hash);
} }
@@ -261,47 +261,53 @@ LedgerAcquire::pointer LedgerAcquireMaster::find(const uint256& hash)
{ {
boost::mutex::scoped_lock sl(mLock); boost::mutex::scoped_lock sl(mLock);
std::map<uint256, LedgerAcquire::pointer>::iterator it=mLedgers.find(hash); std::map<uint256, LedgerAcquire::pointer>::iterator it=mLedgers.find(hash);
if(it!=mLedgers.end()) return it->second; if (it != mLedgers.end()) return it->second;
return LedgerAcquire::pointer(); return LedgerAcquire::pointer();
} }
bool LedgerAcquireMaster::hasLedger(const uint256& hash) bool LedgerAcquireMaster::hasLedger(const uint256& hash)
{ {
boost::mutex::scoped_lock sl(mLock); boost::mutex::scoped_lock sl(mLock);
return mLedgers.find(hash)!=mLedgers.end(); return mLedgers.find(hash) != mLedgers.end();
}
bool LedgerAcquireMaster::dropLedger(const uint256& hash)
{
boost::mutex::scoped_lock sl(mLock);
return mLedgers.erase(hash);
} }
bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet) bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet)
{ {
uint256 hash; uint256 hash;
if(packet.ledgerhash().size()!=32) return false; if (packet.ledgerhash().size() != 32) return false;
memcpy(&hash, packet.ledgerhash().data(), 32); memcpy(&hash, packet.ledgerhash().data(), 32);
LedgerAcquire::pointer ledger=find(hash); LedgerAcquire::pointer ledger=find(hash);
if(!ledger) return false; if (!ledger) return false;
if(packet.type()==newcoin::liBASE) if (packet.type() == newcoin::liBASE)
{ {
if(packet.nodes_size()!=1) return false; if (packet.nodes_size() != 1) return false;
const newcoin::TMLedgerNode& node=packet.nodes(0); const newcoin::TMLedgerNode& node=packet.nodes(0);
if(!node.has_nodedata()) return false; if (!node.has_nodedata()) return false;
return ledger->takeBase(node.nodedata()); return ledger->takeBase(node.nodedata());
} }
else if( (packet.type()==newcoin::liTX_NODE) || (packet.type()==newcoin::liAS_NODE) ) else if ((packet.type() == newcoin::liTX_NODE) || (packet.type() == newcoin::liAS_NODE) )
{ {
std::list<SHAMapNode> nodeIDs; std::list<SHAMapNode> nodeIDs;
std::list<std::vector<unsigned char> > nodeData; std::list<std::vector<unsigned char> > nodeData;
if(packet.nodes().size()<=0) return false; if (packet.nodes().size()<=0) return false;
for(int i=0; i<packet.nodes().size(); i++) for (int i = 0; i<packet.nodes().size(); ++i)
{ {
const newcoin::TMLedgerNode& node=packet.nodes(i); const newcoin::TMLedgerNode& node=packet.nodes(i);
if(!node.has_nodeid() || !node.has_nodedata()) return false; if (!node.has_nodeid() || !node.has_nodedata()) return false;
nodeIDs.push_back(SHAMapNode(node.nodeid().data(), node.nodeid().size())); nodeIDs.push_back(SHAMapNode(node.nodeid().data(), node.nodeid().size()));
nodeData.push_back(std::vector<unsigned char>(node.nodedata().begin(), node.nodedata().end())); nodeData.push_back(std::vector<unsigned char>(node.nodedata().begin(), node.nodedata().end()));
} }
if(packet.type()==newcoin::liTX_NODE) return ledger->takeTxNode(nodeIDs, nodeData); if (packet.type() == newcoin::liTX_NODE) return ledger->takeTxNode(nodeIDs, nodeData);
else return ledger->takeAsNode(nodeIDs, nodeData); else return ledger->takeAsNode(nodeIDs, nodeData);
} }
else return false; else return false;

1
src/LedgerAcquire.h
View File

@@ -64,6 +64,7 @@ public:
LedgerAcquire::pointer findCreate(const uint256& hash); LedgerAcquire::pointer findCreate(const uint256& hash);
LedgerAcquire::pointer find(const uint256& hash); LedgerAcquire::pointer find(const uint256& hash);
bool hasLedger(const uint256& ledgerHash); bool hasLedger(const uint256& ledgerHash);
bool dropLedger(const uint256& ledgerHash);
bool gotLedgerData(newcoin::TMLedgerData& packet); bool gotLedgerData(newcoin::TMLedgerData& packet);
}; };