ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-19 10:35:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Begin replacing old logic with new.

Browse Source
This commit is contained in:
JoelKatz
2013-08-08 14:21:03 -07:00
parent d469e4fc6e
commit 93b8e561ae
11 changed files with 62 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
modules/ripple_app/consensus/ripple_LedgerConsensus.cpp
View File

@@ -1302,7 +1302,7 @@ void LedgerConsensus::accept (SHAMap::ref set, LoadEvent::pointer)
WriteLog (lsDEBUG, LedgerConsensus) << "Applying transactions from current open ledger";
applyTransactions (getApp().getLedgerMaster ().getCurrentLedger ()->peekTransactionMap (), newOL, newLCL,
failedTransactions, true);
getApp().getLedgerMaster ().pushLedger (newLCL, newOL, !mConsensusFail);
getApp().getLedgerMaster ().pushLedger (newLCL, newOL);
mNewLedgerHash = newLCL->getHash ();
mState = lcsACCEPTED;
sl.unlock ();

33
modules/ripple_app/ledger/Ledger.cpp
View File

@@ -504,9 +504,9 @@ uint256 Ledger::getHash ()
return mHash;
}
void Ledger::saveAcceptedLedger (Job&, bool fromConsensus)
void Ledger::saveValidatedLedger (bool current)
{
WriteLog (lsTRACE, Ledger) << "saveAcceptedLedger " << (fromConsensus ? "fromConsensus " : "fromAcquire ") << getLedgerSeq ();
WriteLog (lsTRACE, Ledger) << "saveValidatedLedger " << (current ? "" : "fromAcquire ") << getLedgerSeq ();
static boost::format deleteLedger ("DELETE FROM Ledgers WHERE LedgerSeq = %u;");
static boost::format deleteTrans1 ("DELETE FROM Transactions WHERE LedgerSeq = %u;");
static boost::format deleteTrans2 ("DELETE FROM AccountTransactions WHERE LedgerSeq = %u;");
@@ -527,7 +527,7 @@ void Ledger::saveAcceptedLedger (Job&, bool fromConsensus)
if (getAccountHash () != mAccountStateMap->getHash ())
{
WriteLog (lsFATAL, Ledger) << "sAL: " << getAccountHash () << " != " << mAccountStateMap->getHash ();
WriteLog (lsFATAL, Ledger) << "saveAcceptedLedger: seq=" << mLedgerSeq << ", fromcons=" << fromConsensus;
WriteLog (lsFATAL, Ledger) << "saveAcceptedLedger: seq=" << mLedgerSeq << ", current=" << current;
assert (false);
}
@@ -612,9 +612,6 @@ void Ledger::saveAcceptedLedger (Job&, bool fromConsensus)
mCloseResolution % mCloseFlags % mAccountHash.GetHex () % mTransHash.GetHex ()));
}
if (!fromConsensus && (getConfig ().NODE_SIZE < 2)) // tiny or small
dropCache ();
{ // Clients can now trust the database for information about this ledger sequence
boost::mutex::scoped_lock sl (sPendingSaveLock);
sPendingSaves.erase(getLedgerSeq());
@@ -1817,24 +1814,32 @@ uint32 Ledger::roundCloseTime (uint32 closeTime, uint32 closeResolution)
return closeTime - (closeTime % closeResolution);
}
void Ledger::pendSave (bool fromConsensus)
bool Ledger::pendSaveValidated (bool isSynchronous, bool isCurrent)
{
if (!fromConsensus && !getApp().getHashRouter ().setFlag (getHash (), SF_SAVED))
return;
if (!getApp().getHashRouter ().setFlag (getHash (), SF_SAVED))
return false;
assert (isImmutable ());
{
boost::mutex::scoped_lock sl (sPendingSaveLock);
if (!sPendingSaves.insert(getLedgerSeq()).second)
return;
return false;
}
getApp().getJobQueue ().addJob (
fromConsensus ? jtPUBLEDGER : jtPUBOLDLEDGER,
fromConsensus ? "Ledger::pendSave" : "Ledger::pendOldSave",
BIND_TYPE (&Ledger::saveAcceptedLedger, shared_from_this (), P_1, fromConsensus));
if (isSynchronous)
{
saveValidatedLedger(isCurrent);
}
else
{
getApp().getJobQueue ().addJob (
isCurrent ? jtPUBLEDGER : jtPUBOLDLEDGER,
isCurrent ? "Ledger::pendSave" : "Ledger::pendOldSave",
BIND_TYPE (&Ledger::saveValidatedLedgerAsync, shared_from_this (), P_1, isCurrent));
}
return true;
}
std::set<uint32> Ledger::getPendingSaves()

8
modules/ripple_app/ledger/Ledger.h
View File

@@ -236,7 +236,7 @@ public:
static uint256 getHashByIndex (uint32 index);
static bool getHashesByIndex (uint32 index, uint256 & ledgerHash, uint256 & parentHash);
static std::map< uint32, std::pair<uint256, uint256> > getHashesByIndex (uint32 minSeq, uint32 maxSeq);
void pendSave (bool fromConsensus);
bool pendSaveValidated (bool isSynchronous, bool isCurrent);
// next/prev function
SLE::pointer getSLE (uint256 const & uHash); // SLE is mutable
@@ -435,7 +435,11 @@ protected:
// returned SLE is immutable
SLE::pointer getASNodeI (uint256 const & nodeID, LedgerEntryType let);
void saveAcceptedLedger (Job&, bool fromConsensus);
void saveValidatedLedgerAsync(Job&, bool current)
{
saveValidatedLedger(current);
}
void saveValidatedLedger (bool current);
void updateFees ();

50
modules/ripple_app/ledger/LedgerMaster.cpp
View File

@@ -93,21 +93,18 @@ void LedgerMaster::pushLedger (Ledger::pointer newLedger)
boost::recursive_mutex::scoped_lock ml (mLock);
if (!mPubLedger)
mPubLedger = newLedger;
if (!!mFinalizedLedger)
if (mClosedLedger)
{
mFinalizedLedger->setClosed ();
WriteLog (lsTRACE, LedgerMaster) << "Finalizes: " << mFinalizedLedger->getHash ();
mClosedLedger->setClosed ();
WriteLog (lsTRACE, LedgerMaster) << "Finalizes: " << mClosedLedger->getHash ();
}
mFinalizedLedger = mCurrentLedger;
mClosedLedger = mCurrentLedger;
mCurrentLedger = newLedger;
mEngine.setLedger (newLedger);
}
void LedgerMaster::pushLedger (Ledger::pointer newLCL, Ledger::pointer newOL, bool fromConsensus)
void LedgerMaster::pushLedger (Ledger::pointer newLCL, Ledger::pointer newOL)
{
assert (newLCL->isClosed () && newLCL->isAccepted ());
assert (!newOL->isClosed () && !newOL->isAccepted ());
@@ -118,13 +115,13 @@ void LedgerMaster::pushLedger (Ledger::pointer newLCL, Ledger::pointer newOL, bo
{
assert (newLCL->isClosed ());
assert (newLCL->isImmutable ());
mLedgerHistory.addAcceptedLedger (newLCL, fromConsensus);
mLedgerHistory.addAcceptedLedger (newLCL);
WriteLog (lsINFO, LedgerMaster) << "StashAccepted: " << newLCL->getHash ();
}
{
boost::recursive_mutex::scoped_lock ml (mLock);
mFinalizedLedger = newLCL;
mClosedLedger = newLCL;
mCurrentLedger = newOL;
mEngine.setLedger (newOL);
}
@@ -138,9 +135,9 @@ void LedgerMaster::switchLedgers (Ledger::pointer lastClosed, Ledger::pointer cu
{
boost::recursive_mutex::scoped_lock ml (mLock);
mFinalizedLedger = lastClosed;
mFinalizedLedger->setClosed ();
mFinalizedLedger->setAccepted ();
mClosedLedger = lastClosed;
mClosedLedger->setClosed ();
mClosedLedger->setAccepted ();
mCurrentLedger = current;
assert (!mCurrentLedger->isClosed ());
@@ -154,7 +151,7 @@ void LedgerMaster::storeLedger (Ledger::pointer ledger)
mLedgerHistory.addLedger (ledger);
if (ledger->isAccepted ())
mLedgerHistory.addAcceptedLedger (ledger, false);
mLedgerHistory.addAcceptedLedger (ledger);
}
void LedgerMaster::forceValid (Ledger::pointer ledger)
@@ -344,8 +341,9 @@ void LedgerMaster::asyncAccept (Ledger::pointer ledger)
resumeAcquiring ();
}
bool LedgerMaster::acquireMissingLedger (Ledger::ref origLedger, uint256 const& ledgerHash, uint32 ledgerSeq)
void LedgerMaster::acquireMissingLedger (Ledger::ref origLedger, uint256 const& ledgerHash, uint32 ledgerSeq)
{
#if 0
// return: false = already gave up recently
Ledger::pointer ledger = mLedgerHistory.getLedgerBySeq (ledgerSeq);
@@ -383,12 +381,6 @@ bool LedgerMaster::acquireMissingLedger (Ledger::ref origLedger, uint256 const&
mMissingSeq = ledgerSeq;
if (mMissingLedger->setAccept ())
{
if (!mMissingLedger->addOnComplete (BIND_TYPE (&LedgerMaster::missingAcquireComplete, this, P_1)))
getApp().getIOService ().post (BIND_TYPE (&LedgerMaster::missingAcquireComplete, this, mMissingLedger));
}
int fetchMax = getConfig ().getSize (siLedgerFetch);
int timeoutCount;
int fetchCount = getApp().getInboundLedgers ().getFetchCount (timeoutCount);
@@ -462,10 +454,13 @@ bool LedgerMaster::acquireMissingLedger (Ledger::ref origLedger, uint256 const&
}
return true;
#endif
}
void LedgerMaster::missingAcquireComplete (InboundLedger::pointer acq)
{
#if 0
boost::recursive_mutex::scoped_lock ml (mLock);
if (acq->isFailed () && (mMissingSeq != 0))
@@ -482,6 +477,7 @@ void LedgerMaster::missingAcquireComplete (InboundLedger::pointer acq)
setFullLedger (acq->getLedger ());
mLedgerHistory.addAcceptedLedger (acq->getLedger (), false);
}
#endif
}
bool LedgerMaster::shouldAcquire (uint32 currentLedger, uint32 ledgerHistory, uint32 candidateLedger)
@@ -518,7 +514,7 @@ void LedgerMaster::resumeAcquiring ()
return;
}
uint32 prevMissing = mCompleteLedgers.prevMissing (mFinalizedLedger->getLedgerSeq ());
uint32 prevMissing = mCompleteLedgers.prevMissing (mClosedLedger->getLedgerSeq ());
if (prevMissing == RangeSet::absent)
{
@@ -573,7 +569,7 @@ void LedgerMaster::fixMismatch (Ledger::ref ledger)
CondLog (invalidate != 0, lsWARNING, LedgerMaster) << "All " << invalidate << " prior ledgers invalidated";
}
void LedgerMaster::setFullLedger (Ledger::pointer ledger)
void LedgerMaster::setFullLedger (Ledger::pointer ledger, bool isSynchronous, bool isCurrent)
{
// A new ledger has been accepted as part of the trusted chain
WriteLog (lsDEBUG, LedgerMaster) << "Ledger " << ledger->getLedgerSeq () << " accepted :" << ledger->getHash ();
@@ -587,7 +583,7 @@ void LedgerMaster::setFullLedger (Ledger::pointer ledger)
mCompleteLedgers.setValue (ledger->getLedgerSeq ());
if (Ledger::getHashByIndex (ledger->getLedgerSeq ()) != ledger->getHash ())
ledger->pendSave (false);
ledger->pendSaveValidated (isSynchronous, isCurrent);
if ((ledger->getLedgerSeq () != 0) && mCompleteLedgers.hasValue (ledger->getLedgerSeq () - 1))
{
@@ -780,7 +776,7 @@ void LedgerMaster::tryPublish ()
if (!acq->isDone ())
{
acq->setAccept ();
nothing ();
}
else if (acq->isComplete () && !acq->isFailed ())
{
@@ -791,7 +787,7 @@ void LedgerMaster::tryPublish ()
WriteLog (lsWARNING, LedgerMaster) << "Failed to acquire a published ledger";
getApp().getInboundLedgers().dropLedger(hash);
acq = getApp().getInboundLedgers().findCreate(hash, seq);
acq->setAccept();
nothing ();
if (acq->isDone())
ledger = acq->getLedger();
}
@@ -885,7 +881,7 @@ void LedgerMaster::pubThread ()
BOOST_FOREACH (Ledger::ref l, ledgers)
{
WriteLog (lsDEBUG, LedgerMaster) << "Publishing ledger " << l->getLedgerSeq ();
setFullLedger (l); // OPTIMIZEME: This is actually more work than we need to do
setFullLedger (l, true, true);
getApp().getOPs ().pubLedger (l);
published = true;
}

18
modules/ripple_app/ledger/LedgerMaster.h
View File

@@ -55,7 +55,7 @@ public:
// The finalized ledger is the last closed/accepted ledger
Ledger::ref getClosedLedger ()
{
return mFinalizedLedger;
return mClosedLedger;
}
// The validated ledger is the last fully validated ledger
@@ -86,11 +86,11 @@ public:
}
void pushLedger (Ledger::pointer newLedger);
void pushLedger (Ledger::pointer newLCL, Ledger::pointer newOL, bool fromConsensus);
void pushLedger (Ledger::pointer newLCL, Ledger::pointer newOL);
void storeLedger (Ledger::pointer);
void forceValid (Ledger::pointer);
void setFullLedger (Ledger::pointer ledger);
void setFullLedger (Ledger::pointer ledger, bool isSynchronous, bool isCurrent);
void switchLedgers (Ledger::pointer lastClosed, Ledger::pointer newCurrent);
@@ -117,8 +117,8 @@ public:
if (mCurrentLedger && (mCurrentLedger->getLedgerSeq () == index))
return mCurrentLedger;
if (mFinalizedLedger && (mFinalizedLedger->getLedgerSeq () == index))
return mFinalizedLedger;
if (mClosedLedger && (mClosedLedger->getLedgerSeq () == index))
return mClosedLedger;
Ledger::pointer ret = mLedgerHistory.getLedgerBySeq (index);
@@ -138,8 +138,8 @@ public:
if (mCurrentLedger && (mCurrentLedger->getHash () == hash))
return boost::make_shared<Ledger> (boost::ref (*mCurrentLedger), false);
if (mFinalizedLedger && (mFinalizedLedger->getHash () == hash))
return mFinalizedLedger;
if (mClosedLedger && (mClosedLedger->getHash () == hash))
return mClosedLedger;
return mLedgerHistory.getLedgerByHash (hash);
}
@@ -191,7 +191,7 @@ private:
bool isValidTransaction (Transaction::ref trans);
bool isTransactionOnFutureList (Transaction::ref trans);
bool acquireMissingLedger (Ledger::ref from, uint256 const& ledgerHash, uint32 ledgerSeq);
void acquireMissingLedger (Ledger::ref from, uint256 const& ledgerHash, uint32 ledgerSeq);
void asyncAccept (Ledger::pointer);
void missingAcquireComplete (InboundLedger::pointer);
void pubThread ();
@@ -204,7 +204,7 @@ private:
Ledger::pointer mCurrentLedger; // The ledger we are currently processiong
Ledger::pointer mCurrentSnapshot; // Snapshot of the current ledger
Ledger::pointer mFinalizedLedger; // The ledger that most recently closed
Ledger::pointer mClosedLedger; // The ledger that most recently closed
Ledger::pointer mValidLedger; // The highest-sequence ledger we have fully accepted
Ledger::pointer mPubLedger; // The last ledger we have published

5
modules/ripple_app/ledger/ripple_InboundLedger.cpp
View File

@@ -19,7 +19,6 @@ InboundLedger::InboundLedger (uint256 const& hash, uint32 seq)
, mHaveTransactions (false)
, mAborted (false)
, mSignaled (false)
, mAccept (false)
, mByHash (true)
, mWaitCount (0)
, mSeq (seq)
@@ -267,10 +266,6 @@ void InboundLedger::done ()
{
mLedger->setClosed ();
mLedger->setImmutable ();
if (mAccept)
mLedger->setAccepted ();
getApp().getLedgerMaster ().storeLedger (mLedger);
}
else

12
modules/ripple_app/ledger/ripple_InboundLedger.h
View File

@@ -56,17 +56,6 @@ public:
return mSeq;
}
// VFALCO NOTE what is the meaning of the return value?
bool setAccept ()
{
if (mAccept)
return false;
mAccept = true;
return true;
}
// VFALCO TODO Make thise the Listener / Observer pattern
bool addOnComplete (FUNCTION_TYPE<void (InboundLedger::pointer)>);
@@ -112,7 +101,6 @@ private:
bool mHaveTransactions;
bool mAborted;
bool mSignaled;
bool mAccept;
bool mByHash;
beast::Atomic<int> mWaitCount;
uint32 mSeq;

5
modules/ripple_app/ledger/ripple_LedgerHistory.cpp
View File

@@ -27,7 +27,7 @@ void LedgerHistory::addLedger (Ledger::pointer ledger)
mLedgersByHash.canonicalize (ledger->getHash (), ledger, true);
}
void LedgerHistory::addAcceptedLedger (Ledger::pointer ledger, bool fromConsensus)
void LedgerHistory::addAcceptedLedger (Ledger::pointer ledger)
{
assert (ledger && ledger->isAccepted () && ledger->isImmutable ());
assert (ledger->peekAccountStateMap ()->getHash ().isNonZero ());
@@ -37,9 +37,6 @@ void LedgerHistory::addAcceptedLedger (Ledger::pointer ledger, bool fromConsensu
assert (ledger);
assert (ledger->isAccepted ());
assert (ledger->isImmutable ());
mLedgersByIndex[ledger->getLedgerSeq ()] = ledger->getHash ();
ledger->pendSave (fromConsensus);
}
uint256 LedgerHistory::getLedgerHash (uint32 index)

2
modules/ripple_app/ledger/ripple_LedgerHistory.h
View File

@@ -15,7 +15,7 @@ public:
void addLedger (Ledger::pointer ledger);
void addAcceptedLedger (Ledger::pointer ledger, bool fromConsensus);
void addAcceptedLedger (Ledger::pointer ledger);
float getCacheHitRate ()
{

2
modules/ripple_app/main/ripple_Application.cpp
View File

@@ -815,7 +815,7 @@ void ApplicationImp::startNewLedger ()
Ledger::pointer secondLedger = boost::make_shared<Ledger> (true, boost::ref (*firstLedger));
secondLedger->setClosed ();
secondLedger->setAccepted ();
mLedgerMaster.pushLedger (secondLedger, boost::make_shared<Ledger> (true, boost::ref (*secondLedger)), false);
mLedgerMaster.pushLedger (secondLedger, boost::make_shared<Ledger> (true, boost::ref (*secondLedger)));
assert (!!secondLedger->getAccountState (rootAddress));
mNetOps->setLastCloseTime (secondLedger->getCloseTimeNC ());
}

2
modules/ripple_app/misc/NetworkOPs.cpp
View File

@@ -1272,7 +1272,7 @@ NetworkOPs::getAccountTxs (const RippleAddress& account, int32 minLedger, int32
WriteLog(lsWARNING, NetworkOPs) << "Recovering ledger " << seq << ", txn " << txn->getID();
Ledger::pointer ledger = getLedgerBySeq(seq);
if (ledger)
ledger->pendSave(false);
ledger->pendSaveValidated(false, false);
}
TransactionMetaSet::pointer meta = boost::make_shared<TransactionMetaSet> (txn->getID (), txn->getLedger (), rawMeta.getData ());