Add LedgerHolder class, use in LedgerMaster

Builds/VisualStudio2012/RippleD.vcxproj

@@ -2371,6 +2371,7 @@
     <ClInclude Include="..\..\src\ripple_app\ledger\LedgerMaster.h" />
     <ClInclude Include="..\..\src\ripple_app\ledger\LedgerProposal.h" />
     <ClInclude Include="..\..\src\ripple_app\ledger\LedgerTiming.h" />
+    <ClInclude Include="..\..\src\ripple_app\ledger\LedgerHolder.h" />
     <ClInclude Include="..\..\src\ripple_app\ledger\OrderBookDB.h" />
     <ClInclude Include="..\..\src\ripple_app\ledger\AcceptedLedger.h" />
     <ClInclude Include="..\..\src\ripple_app\ledger\AcceptedLedgerTx.h" />

Builds/VisualStudio2012/RippleD.vcxproj.filters

@@ -1772,6 +1772,9 @@
     <ClInclude Include="..\..\src\ripple_app\ledger\LedgerTiming.h">
       <Filter>[2] Old Ripple\ripple_app\ledger</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\src\ripple_app\ledger\LedgerHolder.h">
+      <Filter>[2] Old Ripple\ripple_app\ledger</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\src\ripple_app\ledger\OrderBookDB.h">
       <Filter>[2] Old Ripple\ripple_app\ledger</Filter>
     </ClInclude>

src/ripple_app/consensus/LedgerConsensus.cpp

@@ -1764,7 +1764,8 @@ private:
         mCloseTime = getApp().getOPs ().getCloseTimeNC ();
         getApp().getOPs ().setLastCloseTime (mCloseTime);
         statusChange (protocol::neCLOSING_LEDGER, *mPreviousLedger);
-        takeInitialPosition (*getApp().getLedgerMaster ().closeLedger (true));
+        getApp().getLedgerMaster().closeLedger (true);
+        takeInitialPosition (*getApp().getLedgerMaster ().getCurrentLedger ());
     }
 
     void checkOurValidation ()

src/ripple_app/ledger/LedgerHolder.h

@@ -0,0 +1,77 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2012, 2013 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef RIPPLE_LEDGERHOLDER_H
+#define RIPPLE_LEDGERHOLDER_H
+
+// Can std::atomic<std::shared_ptr>> make this lock free?
+
+/** Hold a ledger in a thread-safe way.
+*/
+class LedgerHolder
+{
+public:
+    typedef RippleMutex LockType;
+    typedef LockType::ScopedLockType ScopedLockType;
+
+    // Update the held ledger
+    void set (Ledger::pointer ledger)
+    {
+        // The held ledger must always be immutable
+        if (ledger && !ledger->isImmutable ())
+           ledger = boost::make_shared <Ledger> (*ledger, false);
+
+        {
+            ScopedLockType sl (m_lock, __FILE__, __LINE__);
+
+            m_heldLedger = ledger;
+        }
+    }
+
+    // Return the (immutable) held ledger
+    Ledger::pointer get ()
+    {
+        ScopedLockType sl (m_lock, __FILE__, __LINE__);
+
+        return m_heldLedger;
+    }
+
+    // Return a mutable snapshot of the held ledger
+    Ledger::pointer getMutable ()
+    {
+        Ledger::pointer ret = get ();
+        return ret ? boost::make_shared <Ledger> (*ret, true) : ret;
+    }
+
+
+    bool empty ()
+    {
+        ScopedLockType sl (m_lock, __FILE__, __LINE__);
+
+        return m_heldLedger == nullptr;
+    }
+
+private:
+
+    LockType m_lock;
+    Ledger::pointer m_heldLedger;
+
+};
+
+#endif

src/ripple_app/ledger/LedgerMaster.cpp

@@ -42,10 +42,9 @@ public:
 
     TransactionEngine mEngine;
 
-    Ledger::pointer mCurrentLedger;     // The ledger we are currently processiong
+    LedgerHolder mCurrentLedger;        // The ledger we are currently processiong
-    Ledger::pointer mCurrentSnapshot;   // Snapshot of the current ledger
+    LedgerHolder mClosedLedger;         // The ledger that most recently closed
-    Ledger::pointer mClosedLedger;      // The ledger that most recently closed
+    LedgerHolder mValidLedger;          // The highest-sequence ledger we have fully accepted
-    Ledger::pointer mValidLedger;       // The highest-sequence ledger we have fully accepted
     Ledger::pointer mPubLedger;         // The last ledger we have published
     Ledger::pointer mPathLedger;        // The last ledger we did pathfinding against
 
@@ -104,17 +103,7 @@ public:
 
     uint32 getCurrentLedgerIndex ()
     {
-        return mCurrentLedger->getLedgerSeq ();
+        return mCurrentLedger.get ()->getLedgerSeq ();
-    }
-
-    // An immutable snapshot of the current ledger
-    Ledger::ref getCurrentSnapshot ()
-    {
-        if (!mCurrentSnapshot || (mCurrentSnapshot->getHash () != mCurrentLedger->getHash ()))
-            mCurrentSnapshot = boost::make_shared<Ledger> (boost::ref (*mCurrentLedger), false);
-
-        assert (mCurrentSnapshot->isImmutable ());
-        return mCurrentSnapshot;
     }
 
     int getPublishedLedgerAge ()
@@ -175,7 +164,7 @@ public:
 
     void setValidLedger(Ledger::ref l)
     {
-        mValidLedger =  l;
+        mValidLedger.set (l);
         mValidLedgerClose = l->getCloseTimeNC();
         mValidLedgerSeq = l->getLedgerSeq();
     }
@@ -203,14 +192,15 @@ public:
         {
             ScopedLockType ml (m_mutex, __FILE__, __LINE__);
 
-            if (mClosedLedger)
+            Ledger::pointer closedLedger = mCurrentLedger.getMutable ();
+            if (closedLedger)
             {
-                mClosedLedger->setClosed ();
+                closedLedger->setClosed ();
-                WriteLog (lsTRACE, LedgerMaster) << "Finalizes: " << mClosedLedger->getHash ();
+                closedLedger->setImmutable ();
-            }
+                mClosedLedger.set (closedLedger);
+	    }
 
-            mClosedLedger = mCurrentLedger;
+            mCurrentLedger.set (newLedger);
-            mCurrentLedger = newLedger;
             mEngine.setLedger (newLedger);
         }
 
@@ -231,8 +221,8 @@ public:
 
         {
             ScopedLockType ml (m_mutex, __FILE__, __LINE__);
-            mClosedLedger = newLCL;
+            mClosedLedger.set (newLCL);
-            mCurrentLedger = newOL;
+            mCurrentLedger.set (newOL);
             mEngine.setLedger (newOL);
         }
 
@@ -254,13 +244,15 @@ public:
 
         {
             ScopedLockType ml (m_mutex, __FILE__, __LINE__);
-            mClosedLedger = lastClosed;
-            mClosedLedger->setClosed ();
-            mClosedLedger->setAccepted ();
-            mCurrentLedger = current;
 
-            assert (!mCurrentLedger->isClosed ());
+            lastClosed->setClosed ();
-            mEngine.setLedger (mCurrentLedger);
+            lastClosed->setAccepted ();
+
+            mCurrentLedger.set (current);
+            mClosedLedger.set (lastClosed);
+
+            assert (!current->isClosed ());
+            mEngine.setLedger (current);
         }
         checkAccept (lastClosed);
     }
@@ -281,10 +273,10 @@ public:
         setFullLedger(ledger, true, false);
     }
 
-    Ledger::pointer closeLedger (bool recover)
+    void closeLedger (bool recover)
     {
         ScopedLockType sl (m_mutex, __FILE__, __LINE__);
-        Ledger::pointer closingLedger = mCurrentLedger;
+        Ledger::pointer closingLedger = mCurrentLedger.getMutable ();
 
         if (recover)
         {
@@ -318,10 +310,8 @@ public:
             mHeldTransactions.reset (closingLedger->getHash ());
         }
 
-        mCurrentLedger = boost::make_shared<Ledger> (boost::ref (*closingLedger), true);
+        mCurrentLedger.set (closingLedger);
-        mEngine.setLedger (mCurrentLedger);
+        mEngine.setLedger (mCurrentLedger.getMutable ());
-
-        return Ledger::pointer (new Ledger (*closingLedger, true));
     }
 
     TER doTransaction (SerializedTransaction::ref txn, TransactionEngineParams params, bool& didApply)
@@ -335,7 +325,10 @@ public:
             ledger = mEngine.getLedger ();
         }
         if (didApply)
+        {
+           mCurrentLedger.set (ledger);
            getApp().getOPs ().pubProposedTransaction (ledger, txn, result);
+        }
         return result;
     }
 
@@ -583,7 +576,7 @@ public:
 
             ScopedLockType ml (m_mutex, __FILE__, __LINE__);
 
-            if (!mValidLedger || (ledger->getLedgerSeq() > mValidLedger->getLedgerSeq()))
+            if (ledger->getLedgerSeq() > mValidLedgerSeq)
                 setValidLedger(ledger);
             if (!mPubLedger)
             {
@@ -642,13 +635,13 @@ public:
 
     void checkAccept (Ledger::ref ledger)
     {
-        if (ledger->getLedgerSeq() <= mValidLedgerSeq.load())
+        if (ledger->getLedgerSeq() <= mValidLedgerSeq)
             return;
 
         // Can we advance the last fully-validated ledger? If so, can we publish?
         ScopedLockType ml (m_mutex, __FILE__, __LINE__);
 
-        if (mValidLedger && (ledger->getLedgerSeq() <= mValidLedger->getLedgerSeq ()))
+        if (ledger->getLedgerSeq() <= mValidLedgerSeq)
             return;
 
         int minVal = mMinValidations;
@@ -704,7 +697,7 @@ public:
     void advanceThread()
     {
         ScopedLockType sl (m_mutex, __FILE__, __LINE__);
-        assert (mValidLedger && mAdvanceThread);
+        assert (!mValidLedger.empty () && mAdvanceThread);
 
         WriteLog (lsTRACE, LedgerMaster) << "advanceThread<";
 
@@ -734,7 +727,7 @@ public:
             {
                 if (!getConfig().RUN_STANDALONE && !getApp().getFeeTrack().isLoadedLocal() &&
                     (getApp().getJobQueue().getJobCount(jtPUBOLDLEDGER) < 10) &&
-                    (mValidLedger->getLedgerSeq() == mPubLedger->getLedgerSeq()))
+                    (mValidLedgerSeq == mPubLedgerSeq))
                 { // We are in sync, so can acquire
                     uint32 missing;
                     {
@@ -743,7 +736,7 @@ public:
                     }
                     WriteLog (lsTRACE, LedgerMaster) << "tryAdvance discovered missing " << missing;
                     if ((missing != RangeSet::absent) && (missing > 0) &&
-                        shouldAcquire(mValidLedger->getLedgerSeq(), getConfig().LEDGER_HISTORY, missing) &&
+                        shouldAcquire(mValidLedgerSeq, getConfig().LEDGER_HISTORY, missing) &&
                         ((mFillInProgress == 0) || (missing > mFillInProgress)))
                     {
                         WriteLog (lsTRACE, LedgerMaster) << "advanceThread should acquire";
@@ -809,13 +802,13 @@ public:
                             else
                             {
                                 WriteLog (lsFATAL, LedgerMaster) << "Unable to find ledger following prevMissing " << missing;
-                                WriteLog (lsFATAL, LedgerMaster) << "Pub:" << mPubLedger->getLedgerSeq() << " Val:" << mValidLedger->getLedgerSeq();
+                                WriteLog (lsFATAL, LedgerMaster) << "Pub:" << mPubLedgerSeq << " Val:" << mValidLedgerSeq;
                                 WriteLog (lsFATAL, LedgerMaster) << "Ledgers: " << getApp().getLedgerMaster().getCompleteLedgers();
                                 clearLedger (missing + 1);
                                 progress = true;
                             }
                         }
-                        if (mValidLedger->getLedgerSeq() != mPubLedger->getLedgerSeq())
+                        if (mValidLedgerSeq != mPubLedgerSeq)
                         {
                             WriteLog (lsDEBUG, LedgerMaster) << "tryAdvance found last valid changed";
                             progress = true;
@@ -857,24 +850,25 @@ public:
         WriteLog (lsTRACE, LedgerMaster) << "findNewLedgersToPublish<";
         if (!mPubLedger)
         {
-            WriteLog (lsINFO, LedgerMaster) << "First published ledger will be " << mValidLedger->getLedgerSeq();
+            WriteLog (lsINFO, LedgerMaster) << "First published ledger will be " << mValidLedgerSeq;
-            ret.push_back (mValidLedger);
+            ret.push_back (mValidLedger.get ());
         }
-        else if (mValidLedger->getLedgerSeq () > (mPubLedger->getLedgerSeq () + MAX_LEDGER_GAP))
+        else if (mValidLedgerSeq > (mPubLedgerSeq + MAX_LEDGER_GAP))
         {
-            WriteLog (lsWARNING, LedgerMaster) << "Gap in validated ledger stream " << mPubLedger->getLedgerSeq () << " - " <<
+            WriteLog (lsWARNING, LedgerMaster) << "Gap in validated ledger stream " << mPubLedgerSeq << " - " <<
-                                               mValidLedger->getLedgerSeq () - 1;
+                                               mValidLedgerSeq - 1;
-            ret.push_back (mValidLedger);
+            Ledger::pointer valLedger = mValidLedger.get ();
-            setPubLedger (mValidLedger);
+            ret.push_back (valLedger);
-            getApp().getOrderBookDB().setup(mValidLedger);
+            setPubLedger (valLedger);
+            getApp().getOrderBookDB().setup(valLedger);
         }
-        else if (mValidLedger->getLedgerSeq () > mPubLedger->getLedgerSeq ())
+        else if (mValidLedgerSeq > mPubLedgerSeq)
         {
             int acqCount = 0;
 
-            uint32 pubSeq = mPubLedger->getLedgerSeq() + 1; // Next sequence to publish
+            uint32 pubSeq = mPubLedgerSeq + 1; // Next sequence to publish
-            uint32 valSeq = mValidLedger->getLedgerSeq();
+            Ledger::pointer valLedger = mValidLedger.get ();
-            Ledger::pointer valLedger = mValidLedger;
+            uint32 valSeq = valLedger->getLedgerSeq ();
 
             ScopedUnlockType sul(m_mutex, __FILE__, __LINE__);
             try
@@ -953,7 +947,7 @@ public:
 
         // Can't advance without at least one fully-valid ledger
         mAdvanceWork = true;
-        if (!mAdvanceThread && mValidLedger)
+        if (!mAdvanceThread && !mValidLedger.empty ())
         {
             mAdvanceThread = true;
             getApp().getJobQueue ().addJob (jtADVANCE, "advanceLedger",
@@ -995,7 +989,7 @@ public:
     {
         {
             ScopedLockType ml (m_mutex, __FILE__, __LINE__);
-            if (getApp().getOPs().isNeedNetworkLedger () || !mCurrentLedger)
+            if (getApp().getOPs().isNeedNetworkLedger () || mCurrentLedger.empty ())
             {
                 --mPathFindThread;
                 return;
@@ -1009,15 +1003,15 @@ public:
             {
                 ScopedLockType ml (m_mutex, __FILE__, __LINE__);
 
-                if (mValidLedger &&
+                if (!mValidLedger.empty() &&
-                    (!mPathLedger || (mPathLedger->getLedgerSeq() != mValidLedger->getLedgerSeq())))
+                    (!mPathLedger || (mPathLedger->getLedgerSeq() != mValidLedgerSeq)))
                 { // We have a new valid ledger since the last full pathfinding
-                    mPathLedger = mValidLedger;
+                    mPathLedger = mValidLedger.get ();
                     lastLedger = mPathLedger;
                 }
                 else if (mPathFindNewRequest)
                 { // We have a new request but no new ledger
-                    lastLedger = boost::make_shared<Ledger> (boost::ref (*mCurrentLedger), false);
+                    lastLedger = mCurrentLedger.get ();
                 }
                 else
                 { // Nothing to do
@@ -1095,21 +1089,21 @@ public:
     }
 
     // The current ledger is the ledger we believe new transactions should go in
-    Ledger::ref getCurrentLedger ()
+    Ledger::pointer getCurrentLedger ()
     {
-        return mCurrentLedger;
+        return mCurrentLedger.get ();
     }
 
     // The finalized ledger is the last closed/accepted ledger
-    Ledger::ref getClosedLedger ()
+    Ledger::pointer getClosedLedger ()
     {
-        return mClosedLedger;
+        return mClosedLedger.get ();
     }
 
     // The validated ledger is the last fully validated ledger
-    Ledger::ref getValidatedLedger ()
+    Ledger::pointer getValidatedLedger ()
     {
-        return mValidLedger;
+        return mValidLedger.get ();
     }
 
     // This is the last ledger we published to clients and can lag the validated ledger
@@ -1164,10 +1158,7 @@ public:
         uint256 ledgerHash;
         Ledger::pointer referenceLedger;
 
-        {
+        referenceLedger = mValidLedger.get ();
-            ScopedLockType sl (m_mutex, __FILE__, __LINE__);
-            referenceLedger = mValidLedger;
-        }
         if (referenceLedger)
             ledgerHash = walkHashBySeq (index, referenceLedger);
         return ledgerHash;
@@ -1211,20 +1202,18 @@ public:
 
     Ledger::pointer getLedgerBySeq (uint32 index)
     {
-        {
-            ScopedLockType sl (m_mutex, __FILE__, __LINE__);
-            if (mCurrentLedger && (mCurrentLedger->getLedgerSeq () == index))
-                return mCurrentLedger;
-
-                if (mClosedLedger && (mClosedLedger->getLedgerSeq () == index))
-                return mClosedLedger;
-        }
-
         Ledger::pointer ret = mLedgerHistory.getLedgerBySeq (index);
-
         if (ret)
             return ret;
 
+        ret = mCurrentLedger.get ();
+        if (ret && (ret->getLedgerSeq () == index))
+            return ret;
+
+        ret = mClosedLedger.get ();
+        if (ret && (ret->getLedgerSeq () == index))
+            return ret;
+
         clearLedger (index);
         return ret;
     }
@@ -1232,15 +1221,21 @@ public:
     Ledger::pointer getLedgerByHash (uint256 const& hash)
     {
         if (hash.isZero ())
-            return boost::make_shared<Ledger> (boost::ref (*mCurrentLedger), false);
+            return mCurrentLedger.get ();
 
-        if (mCurrentLedger && (mCurrentLedger->getHash () == hash))
+        Ledger::pointer ret = mLedgerHistory.getLedgerByHash (hash);
-            return boost::make_shared<Ledger> (boost::ref (*mCurrentLedger), false);
+        if (ret)
+            return ret;
 
-        if (mClosedLedger && (mClosedLedger->getHash () == hash))
+        ret = mCurrentLedger.get ();
-            return mClosedLedger;
+        if (ret && (ret->getHash () == hash))
+            return ret;
 
-        return mLedgerHistory.getLedgerByHash (hash);
+        ret = mClosedLedger.get ();
+        if (ret && (ret->getHash () == hash))
+            return ret;
+
+        return Ledger::pointer ();
     }
 
     void doLedgerCleaner(const Json::Value& parameters)

src/ripple_app/ledger/LedgerMaster.h

@@ -50,16 +50,13 @@ public:
     virtual LockType& peekMutex () = 0;
 
     // The current ledger is the ledger we believe new transactions should go in
-    virtual Ledger::ref getCurrentLedger () = 0;
+    virtual Ledger::pointer getCurrentLedger () = 0;
-
-    // An immutable snapshot of the current ledger
-    virtual Ledger::ref getCurrentSnapshot () = 0;
 
     // The finalized ledger is the last closed/accepted ledger
-    virtual Ledger::ref getClosedLedger () = 0;
+    virtual Ledger::pointer getClosedLedger () = 0;
 
     // The validated ledger is the last fully validated ledger
-    virtual Ledger::ref getValidatedLedger () = 0;
+    virtual Ledger::pointer getValidatedLedger () = 0;
 
     // This is the last ledger we published to clients and can lag the validated ledger
     virtual Ledger::ref getPublishedLedger () = 0;
@@ -89,7 +86,7 @@ public:
 
     virtual std::string getCompleteLedgers () = 0;
 
-    virtual Ledger::pointer closeLedger (bool recoverHeldTransactions) = 0;
+    virtual void closeLedger (bool recoverHeldTransactions) = 0;
 
     /** Get a ledger's hash by sequence number using the cache
     */

src/ripple_app/misc/NetworkOPs.cpp

@@ -75,26 +75,22 @@ public:
     }
     std::string strOperatingMode ();
 
-    Ledger::ref     getClosedLedger ()
+    Ledger::pointer     getClosedLedger ()
     {
         return m_ledgerMaster.getClosedLedger ();
     }
-    Ledger::ref     getValidatedLedger ()
+    Ledger::pointer     getValidatedLedger ()
     {
         return m_ledgerMaster.getValidatedLedger ();
     }
-    Ledger::ref     getPublishedLedger ()
+    Ledger::pointer     getPublishedLedger ()
     {
         return m_ledgerMaster.getPublishedLedger ();
     }
-    Ledger::ref     getCurrentLedger ()
+    Ledger::pointer     getCurrentLedger ()
     {
         return m_ledgerMaster.getCurrentLedger ();
     }
-    Ledger::ref     getCurrentSnapshot ()
-    {
-        return m_ledgerMaster.getCurrentSnapshot ();
-    }
     Ledger::pointer getLedgerByHash (uint256 const& hash)
     {
         return m_ledgerMaster.getLedgerByHash (hash);
@@ -2289,7 +2285,7 @@ void NetworkOPsImp::pubProposedTransaction (Ledger::ref lpCurrent, SerializedTra
     }
     AcceptedLedgerTx alt (stTxn, terResult);
     m_journal.trace << "pubProposed: " << alt.getJson ();
-    pubAccountTransaction (lpCurrent, AcceptedLedgerTx (stTxn, terResult), false);
+    pubAccountTransaction (lpCurrent, alt, false);
 }
 
 void NetworkOPsImp::pubLedger (Ledger::ref accepted)

src/ripple_app/misc/NetworkOPs.h

@@ -103,11 +103,10 @@ public:
 
     virtual OperatingMode getOperatingMode () = 0;
     virtual std::string strOperatingMode () = 0;
-    virtual Ledger::ref     getClosedLedger () = 0;
+    virtual Ledger::pointer getClosedLedger () = 0;
-    virtual Ledger::ref     getValidatedLedger () = 0;
+    virtual Ledger::pointer getValidatedLedger () = 0;
-    virtual Ledger::ref     getPublishedLedger () = 0;
+    virtual Ledger::pointer getPublishedLedger () = 0;
-    virtual Ledger::ref     getCurrentLedger () = 0;
+    virtual Ledger::pointer getCurrentLedger () = 0;
-    virtual Ledger::ref     getCurrentSnapshot () = 0;
     virtual Ledger::pointer getLedgerByHash (uint256 const& hash) = 0;
     virtual Ledger::pointer getLedgerBySeq (const uint32 seq) = 0;
     virtual void            missingNodeInLedger (const uint32 seq) = 0;

src/ripple_app/ripple_app.h

@@ -108,6 +108,7 @@ namespace ripple {
 #include "ledger/LedgerEntrySet.h"
 #include "tx/TransactionEngine.h"
 #include "misc/CanonicalTXSet.h"
+#include "ledger/LedgerHolder.h"
 #include "ledger/LedgerHistory.h"
 #include "ledger/LedgerCleaner.h"
 #include "ledger/LedgerMaster.h"

src/ripple_app/rpc/RPCHandler.cpp

@@ -86,7 +86,7 @@ Json::Value RPCHandler::transactionSign (Json::Value params, bool bSubmit, bool
     }
     std::string sType = txJSON["TransactionType"].asString ();
 
-    Ledger::pointer lSnapshot = mNetOps->getCurrentSnapshot ();
+    Ledger::pointer lSnapshot = mNetOps->getCurrentLedger ();
     AccountState::pointer asSrc = bOffline
                                   ? AccountState::pointer ()                              // Don't look up address if offline.
                                   : mNetOps->getAccountState (lSnapshot, raSrcAddressID);
@@ -3045,7 +3045,7 @@ Json::Value RPCHandler::lookupLedger (Json::Value params, Ledger::pointer& lpLed
     switch (iLedgerIndex)
     {
     case LEDGER_CURRENT:
-        lpLedger        = mNetOps->getCurrentSnapshot ();
+        lpLedger        = mNetOps->getCurrentLedger ();
         iLedgerIndex    = lpLedger->getLedgerSeq ();
         assert (lpLedger->isImmutable () && !lpLedger->isClosed ());
         break;