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

Abstract out the peer set and timing code fromt he ledger acquire logic.

Browse Source 
There's probably a better way to handle the timer lambda, but this works.
This commit is contained in:
JoelKatz
2012-05-12 22:14:16 -07:00
parent e0cb27f1c1
commit b74e64bd76
2 changed files with 110 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
src/LedgerAcquire.cpp
View File

@@ -9,15 +9,77 @@
#define LEDGER_ACQUIRE_TIMEOUT 2
LedgerAcquire::LedgerAcquire(const uint256& hash) : mHash(hash),
mComplete(false), mFailed(false), mHaveBase(false), mHaveState(false), mHaveTransactions(false),
mTimer(theApp->getIOService())
PeerSet::PeerSet(const uint256& hash, int interval) : mHash(hash), mTimerInterval(interval),
mComplete(false), mFailed(false), mTimer(theApp->getIOService())
{ ; }
void PeerSet::peerHas(Peer::pointer ptr)
{
boost::recursive_mutex::scoped_lock sl(mLock);
std::list<boost::weak_ptr<Peer> >::iterator it = mPeers.begin();
while (it != mPeers.end())
{
Peer::pointer pr = it->lock();
if (!pr) // we have a dead entry, remove it
it = mPeers.erase(it);
else
{
if (pr->samePeer(ptr)) return; // we already have this peer
++it;
}
}
mPeers.push_back(ptr);
newPeer(ptr);
}
void PeerSet::badPeer(Peer::pointer ptr)
{
boost::recursive_mutex::scoped_lock sl(mLock);
std::list<boost::weak_ptr<Peer> >::iterator it=mPeers.begin();
while (it != mPeers.end())
{
Peer::pointer pr = it->lock();
if (!pr) // we have a dead entry, remove it
it = mPeers.erase(it);
else
{
if (ptr->samePeer(pr))
{ // We found a pointer to the bad peer
mPeers.erase(it);
return;
}
++it;
}
}
}
void PeerSet::resetTimer()
{
mTimer.expires_from_now(boost::posix_time::seconds(mTimerInterval));
mTimer.async_wait(getTimerLamba());
}
void LedgerAcquire::LATimerEntry(boost::weak_ptr<LedgerAcquire> wptr, const boost::system::error_code& result)
{
if (result == boost::asio::error::operation_aborted) return;
boost::shared_ptr<LedgerAcquire> ptr = wptr.lock();
if (!!ptr) ptr->onTimer();
}
LedgerAcquire::LedgerAcquire(const uint256& hash) : PeerSet(hash, LEDGER_ACQUIRE_TIMEOUT),
mHaveBase(false), mHaveState(false), mHaveTransactions(false)
{
#ifdef DEBUG
std::cerr << "Acquiring ledger " << mHash.GetHex() << std::endl;
#endif
}
boost::function<void (boost::system::error_code)> LedgerAcquire::getTimerLamba()
{
return boost::bind(&LedgerAcquire::LATimerEntry, boost::weak_ptr<LedgerAcquire>(shared_from_this()),
boost::asio::placeholders::error);
}
void LedgerAcquire::done()
{
#ifdef DEBUG
@@ -25,28 +87,23 @@ void LedgerAcquire::done()
#endif
std::vector< boost::function<void (LedgerAcquire::pointer)> > triggers;
setComplete();
mLock.lock();
triggers = mOnComplete;
mOnComplete.empty();
mLock.unlock();
for (int i = 0; i<triggers.size(); ++i)
triggers[i](shared_from_this());
triggers[i](boost::enable_shared_from_this<LedgerAcquire>::shared_from_this());
}
void LedgerAcquire::resetTimer()
struct null_deleter
{
mTimer.expires_from_now(boost::posix_time::seconds(LEDGER_ACQUIRE_TIMEOUT));
mTimer.async_wait(boost::bind(&LedgerAcquire::timerEntry,
boost::weak_ptr<LedgerAcquire>(shared_from_this()), boost::asio::placeholders::error));
}
void LedgerAcquire::timerEntry(boost::weak_ptr<LedgerAcquire> wptr, const boost::system::error_code& result)
{
if (result == boost::asio::error::operation_aborted) return;
LedgerAcquire::pointer ptr = wptr.lock();
if (!!ptr) ptr->trigger(Peer::pointer());
}
void operator()(void const *) const
{ // weak pointers never need to delete
assert(false);
}
};
void LedgerAcquire::addOnComplete(boost::function<void (LedgerAcquire::pointer)> trigger)
{
@@ -217,46 +274,6 @@ void LedgerAcquire::sendRequest(boost::shared_ptr<newcoin::TMGetLedger> tmGL)
}
}
void LedgerAcquire::peerHas(Peer::pointer ptr)
{
boost::recursive_mutex::scoped_lock sl(mLock);
std::list<boost::weak_ptr<Peer> >::iterator it = mPeers.begin();
while (it != mPeers.end())
{
Peer::pointer pr = it->lock();
if (!pr) // we have a dead entry, remove it
it = mPeers.erase(it);
else
{
if (pr->samePeer(ptr)) return; // we already have this peer
++it;
}
}
mPeers.push_back(ptr);
if (mPeers.size() == 1) trigger(ptr);
}
void LedgerAcquire::badPeer(Peer::pointer ptr)
{
boost::recursive_mutex::scoped_lock sl(mLock);
std::list<boost::weak_ptr<Peer> >::iterator it=mPeers.begin();
while (it != mPeers.end())
{
Peer::pointer pr = it->lock();
if (!pr) // we have a dead entry, remove it
it = mPeers.erase(it);
else
{
if (ptr->samePeer(pr))
{ // We found a pointer to the bad peer
mPeers.erase(it);
return;
}
++it;
}
}
}
bool LedgerAcquire::takeBase(const std::string& data, Peer::pointer peer)
{ // Return value: true=normal, false=bad data
#ifdef DEBUG

53
src/LedgerAcquire.h
View File

@@ -13,36 +13,60 @@
#include "Peer.h"
#include "../obj/src/newcoin.pb.h"
class LedgerAcquire : public boost::enable_shared_from_this<LedgerAcquire>
class PeerSet
{
protected:
uint256 mHash;
int mTimerInterval;
bool mComplete, mFailed;
boost::recursive_mutex mLock;
boost::asio::deadline_timer mTimer;
std::list< boost::weak_ptr<Peer> > mPeers;
PeerSet(const uint256& hash, int interval);
public:
const uint256& getHash() const { return mHash; }
bool isComplete() const { return mComplete; }
bool isFailed() const { return mFailed; }
void peerHas(Peer::pointer);
void badPeer(Peer::pointer);
void resetTimer();
protected:
virtual void newPeer(Peer::pointer) = 0;
virtual boost::function<void (boost::system::error_code)> getTimerLamba() = 0;
void setComplete() { mComplete = true; }
void setFailed() { mFailed = true; }
};
class LedgerAcquire : public PeerSet, public boost::enable_shared_from_this<LedgerAcquire>
{ // A ledger we are trying to acquire
public:
typedef boost::shared_ptr<LedgerAcquire> pointer;
protected:
boost::recursive_mutex mLock;
Ledger::pointer mLedger;
uint256 mHash;
bool mComplete, mFailed, mHaveBase, mHaveState, mHaveTransactions;
boost::asio::deadline_timer mTimer;
bool mHaveBase, mHaveState, mHaveTransactions;
std::vector< boost::function<void (LedgerAcquire::pointer)> > mOnComplete;
std::list<boost::weak_ptr<Peer> > mPeers; // peers known to have this ledger
void done();
void onTimer() { trigger(Peer::pointer()); }
static void timerEntry(boost::weak_ptr<LedgerAcquire>, const boost::system::error_code&);
void sendRequest(boost::shared_ptr<newcoin::TMGetLedger> message);
void sendRequest(boost::shared_ptr<newcoin::TMGetLedger> message, Peer::pointer peer);
void trigger(Peer::pointer peer);
void newPeer(Peer::pointer peer) { trigger(peer); }
void trigger(Peer::pointer);
virtual boost::function<void (boost::system::error_code)> getTimerLamba();
static void LATimerEntry(boost::weak_ptr<LedgerAcquire>, const boost::system::error_code&);
public:
LedgerAcquire(const uint256& hash);
const uint256& getHash() const { return mHash; }
bool isComplete() const { return mComplete; }
bool isFailed() const { return mFailed; }
bool isBase() const { return mHaveBase; }
bool isAcctStComplete() const { return mHaveState; }
bool isTransComplete() const { return mHaveTransactions; }
@@ -50,14 +74,11 @@ public:
void addOnComplete(boost::function<void (LedgerAcquire::pointer)>);
void peerHas(Peer::pointer);
void badPeer(Peer::pointer);
bool takeBase(const std::string& data, Peer::pointer);
bool takeTxNode(const std::list<SHAMapNode>& IDs, const std::list<std::vector<unsigned char> >& data,
Peer::pointer);
bool takeAsNode(const std::list<SHAMapNode>& IDs, const std::list<std::vector<unsigned char> >& data,
Peer::pointer);
void resetTimer();
};
class LedgerAcquireMaster