Begin replacing old logic with new.

modules/ripple_app/consensus/ripple_LedgerConsensus.cpp

@@ -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 ();

modules/ripple_app/ledger/Ledger.cpp

@@ -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))
+    if (!getApp().getHashRouter ().setFlag (getHash (), SF_SAVED))
-        return;
+        return false;
 
     assert (isImmutable ());
 
     {
         boost::mutex::scoped_lock sl (sPendingSaveLock);
         if (!sPendingSaves.insert(getLedgerSeq()).second)
-            return;
+            return false;
     }
 
-    getApp().getJobQueue ().addJob (
+    if (isSynchronous)
-        fromConsensus ? jtPUBLEDGER : jtPUBOLDLEDGER,
+    {
-        fromConsensus ? "Ledger::pendSave" : "Ledger::pendOldSave",
+        saveValidatedLedger(isCurrent);
-        BIND_TYPE (&Ledger::saveAcceptedLedger, shared_from_this (), P_1, fromConsensus));
+    }
+    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()

modules/ripple_app/ledger/Ledger.h

@@ -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 ();
 

modules/ripple_app/ledger/LedgerMaster.cpp

@@ -93,21 +93,18 @@ void LedgerMaster::pushLedger (Ledger::pointer newLedger)
 
     boost::recursive_mutex::scoped_lock ml (mLock);
 
-    if (!mPubLedger)
+    if (mClosedLedger)
-        mPubLedger = newLedger;
-
-    if (!!mFinalizedLedger)
     {
-        mFinalizedLedger->setClosed ();
+        mClosedLedger->setClosed ();
-        WriteLog (lsTRACE, LedgerMaster) << "Finalizes: " << mFinalizedLedger->getHash ();
+        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;
+        mClosedLedger = lastClosed;
-        mFinalizedLedger->setClosed ();
+        mClosedLedger->setClosed ();
-        mFinalizedLedger->setAccepted ();
+        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;
         }

modules/ripple_app/ledger/LedgerMaster.h

@@ -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))
+        if (mClosedLedger && (mClosedLedger->getLedgerSeq () == index))
-            return mFinalizedLedger;
+            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))
+        if (mClosedLedger && (mClosedLedger->getHash () == hash))
-            return mFinalizedLedger;
+            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
 

modules/ripple_app/ledger/ripple_InboundLedger.cpp

@@ -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

modules/ripple_app/ledger/ripple_InboundLedger.h

@@ -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;

modules/ripple_app/ledger/ripple_LedgerHistory.cpp

@@ -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)

modules/ripple_app/ledger/ripple_LedgerHistory.h

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

modules/ripple_app/main/ripple_Application.cpp

@@ -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 ());
     }

modules/ripple_app/misc/NetworkOPs.cpp

@@ -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 ());