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

Switch over more files to use the new Log functions

Browse Source
This commit is contained in:
Vinnie Falco
2013-05-22 11:04:11 -07:00
parent 8c880d9275
commit a5ab694e48
10 changed files with 396 additions and 400 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
modules/ripple_ledger/ripple_ledger.cpp
View File

@@ -30,31 +30,27 @@
#pragma warning (disable: 4244) // conversion, possible loss of data #pragma warning (disable: 4244) // conversion, possible loss of data
#endif #endif
#if 0 #include "src/cpp/ripple/Contract.cpp" // no log
#include "src/cpp/ripple/Contract.cpp" #include "src/cpp/ripple/Operation.cpp" // no log
#include "src/cpp/ripple/Operation.cpp"
#include "src/cpp/ripple/AcceptedLedger.cpp" #include "src/cpp/ripple/AcceptedLedger.cpp" // no log
#include "src/cpp/ripple/AccountItems.cpp" #include "src/cpp/ripple/AccountItems.cpp" // no log
#include "src/cpp/ripple/AccountState.cpp" #include "src/cpp/ripple/AccountState.cpp" // no log
#endif
#include "src/cpp/ripple/FeatureTable.cpp" #include "src/cpp/ripple/FeatureTable.cpp"
#include "src/cpp/ripple/Ledger.cpp" #include "src/cpp/ripple/Ledger.cpp"
#if 0
#include "src/cpp/ripple/LedgerAcquire.cpp" #include "src/cpp/ripple/LedgerAcquire.cpp"
#include "src/cpp/ripple/LedgerConsensus.cpp" #include "src/cpp/ripple/LedgerConsensus.cpp"
#include "src/cpp/ripple/LedgerEntrySet.cpp" #include "src/cpp/ripple/LedgerEntrySet.cpp"
#include "src/cpp/ripple/LedgerFormats.cpp" #include "src/cpp/ripple/LedgerFormats.cpp" // no log
#include "src/cpp/ripple/LedgerHistory.cpp" #include "src/cpp/ripple/LedgerHistory.cpp" // no log
#include "src/cpp/ripple/LedgerMaster.cpp" #include "src/cpp/ripple/LedgerMaster.cpp"
#include "src/cpp/ripple/LedgerProposal.cpp" #include "src/cpp/ripple/LedgerProposal.cpp" // no log
#include "src/cpp/ripple/LedgerTiming.cpp" #include "src/cpp/ripple/LedgerTiming.cpp"
#include "src/cpp/ripple/Offer.cpp" #include "src/cpp/ripple/Offer.cpp" // no log
#include "src/cpp/ripple/OrderBook.cpp" #include "src/cpp/ripple/OrderBook.cpp" // no log
#include "src/cpp/ripple/OrderBookDB.cpp" #include "src/cpp/ripple/OrderBookDB.cpp"
#include "src/cpp/ripple/RippleCalc.cpp" #include "src/cpp/ripple/RippleCalc.cpp"
#include "src/cpp/ripple/RippleState.cpp" #include "src/cpp/ripple/RippleState.cpp" // no log
#endif
#ifdef _MSC_VER #ifdef _MSC_VER
//#pragma warning (pop) //#pragma warning (pop)

6
src/cpp/ripple/Ledger.cpp
View File

@@ -643,7 +643,7 @@ Ledger::pointer Ledger::getSQL(const std::string& sql)
ret->setAccepted(); ret->setAccepted();
if (ret->getHash() != ledgerHash) if (ret->getHash() != ledgerHash)
{ {
if (sLog(lsERROR)) if (ShouldLog (lsERROR, Ledger))
{ {
Log(lsERROR) << "Failed on ledger"; Log(lsERROR) << "Failed on ledger";
Json::Value p; Json::Value p;
@@ -1463,13 +1463,13 @@ bool Ledger::walkLedger()
{ {
std::vector<SHAMapMissingNode> missingNodes1, missingNodes2; std::vector<SHAMapMissingNode> missingNodes1, missingNodes2;
mAccountStateMap->walkMap(missingNodes1, 32); mAccountStateMap->walkMap(missingNodes1, 32);
if (sLog(lsINFO) && !missingNodes1.empty()) if (ShouldLog (lsINFO, Ledger) && !missingNodes1.empty())
{ {
Log(lsINFO) << missingNodes1.size() << " missing account node(s)"; Log(lsINFO) << missingNodes1.size() << " missing account node(s)";
Log(lsINFO) << "First: " << missingNodes1[0]; Log(lsINFO) << "First: " << missingNodes1[0];
} }
mTransactionMap->walkMap(missingNodes2, 32); mTransactionMap->walkMap(missingNodes2, 32);
if (sLog(lsINFO) && !missingNodes2.empty()) if (ShouldLog (lsINFO, Ledger) && !missingNodes2.empty())
{ {
Log(lsINFO) << missingNodes2.size() << " missing transaction node(s)"; Log(lsINFO) << missingNodes2.size() << " missing transaction node(s)";
Log(lsINFO) << "First: " << missingNodes2[0]; Log(lsINFO) << "First: " << missingNodes2[0];

109
src/cpp/ripple/LedgerAcquire.cpp
View File

@@ -10,7 +10,6 @@
#include "SHAMapSync.h" #include "SHAMapSync.h"
#include "HashPrefixes.h" #include "HashPrefixes.h"
SETUP_LOG();
DECLARE_INSTANCE(LedgerAcquire); DECLARE_INSTANCE(LedgerAcquire);
#define LA_DEBUG #define LA_DEBUG
@@ -55,7 +54,7 @@ void PeerSet::invokeOnTimer()
if (!mProgress) if (!mProgress)
{ {
++mTimeouts; ++mTimeouts;
cLog(lsWARNING) << "Timeout(" << mTimeouts << ") pc=" << mPeers.size() << " acquiring " << mHash; WriteLog (lsWARNING, LedgerAcquire) << "Timeout(" << mTimeouts << ") pc=" << mPeers.size() << " acquiring " << mHash;
onTimer(false); onTimer(false);
} }
else else
@@ -78,7 +77,7 @@ void PeerSet::TimerEntry(boost::weak_ptr<PeerSet> wptr, const boost::system::err
int jc = theApp->getJobQueue().getJobCountTotal(jtLEDGER_DATA); int jc = theApp->getJobQueue().getJobCountTotal(jtLEDGER_DATA);
if (jc > 4) if (jc > 4)
{ {
cLog(lsDEBUG) << "Deferring PeerSet timer due to load"; WriteLog (lsDEBUG, LedgerAcquire) << "Deferring PeerSet timer due to load";
ptr->setTimer(); ptr->setTimer();
} }
else else
@@ -102,7 +101,7 @@ LedgerAcquire::LedgerAcquire(const uint256& hash, uint32 seq) : PeerSet(hash, LE
mByHash(true), mWaitCount(0), mSeq(seq) mByHash(true), mWaitCount(0), mSeq(seq)
{ {
#ifdef LA_DEBUG #ifdef LA_DEBUG
cLog(lsTRACE) << "Acquiring ledger " << mHash; WriteLog (lsTRACE, LedgerAcquire) << "Acquiring ledger " << mHash;
#endif #endif
tryLocal(); tryLocal();
} }
@@ -129,7 +128,7 @@ bool LedgerAcquire::tryLocal()
std::vector<unsigned char> data; std::vector<unsigned char> data;
if (!theApp->getOPs().getFetchPack(mHash, data)) if (!theApp->getOPs().getFetchPack(mHash, data))
return false; return false;
cLog(lsTRACE) << "Ledger base found in fetch pack"; WriteLog (lsTRACE, LedgerAcquire) << "Ledger base found in fetch pack";
mLedger = boost::make_shared<Ledger>(data, true); mLedger = boost::make_shared<Ledger>(data, true);
theApp->getHashedObjectStore().store(hotLEDGER, mLedger->getLedgerSeq(), data, mHash); theApp->getHashedObjectStore().store(hotLEDGER, mLedger->getLedgerSeq(), data, mHash);
} }
@@ -140,7 +139,7 @@ bool LedgerAcquire::tryLocal()
if (mLedger->getHash() != mHash) if (mLedger->getHash() != mHash)
{ // We know for a fact the ledger can never be acquired { // We know for a fact the ledger can never be acquired
cLog(lsWARNING) << mHash << " cannot be a ledger"; WriteLog (lsWARNING, LedgerAcquire) << mHash << " cannot be a ledger";
mFailed = true; mFailed = true;
return true; return true;
} }
@@ -151,7 +150,7 @@ bool LedgerAcquire::tryLocal()
{ {
if (mLedger->getTransHash().isZero()) if (mLedger->getTransHash().isZero())
{ {
cLog(lsTRACE) << "No TXNs to fetch"; WriteLog (lsTRACE, LedgerAcquire) << "No TXNs to fetch";
mHaveTransactions = true; mHaveTransactions = true;
} }
else else
@@ -160,11 +159,11 @@ bool LedgerAcquire::tryLocal()
{ {
TransactionStateSF filter(mLedger->getLedgerSeq()); TransactionStateSF filter(mLedger->getLedgerSeq());
mLedger->peekTransactionMap()->fetchRoot(mLedger->getTransHash(), &filter); mLedger->peekTransactionMap()->fetchRoot(mLedger->getTransHash(), &filter);
cLog(lsTRACE) << "Got root txn map locally"; WriteLog (lsTRACE, LedgerAcquire) << "Got root txn map locally";
std::vector<uint256> h = mLedger->getNeededTransactionHashes(1, &filter); std::vector<uint256> h = mLedger->getNeededTransactionHashes(1, &filter);
if (h.empty()) if (h.empty())
{ {
cLog(lsTRACE) << "Had full txn map locally"; WriteLog (lsTRACE, LedgerAcquire) << "Had full txn map locally";
mHaveTransactions = true; mHaveTransactions = true;
} }
} }
@@ -178,7 +177,7 @@ bool LedgerAcquire::tryLocal()
{ {
if (mLedger->getAccountHash().isZero()) if (mLedger->getAccountHash().isZero())
{ {
cLog(lsFATAL) << "We are acquiring a ledger with a zero account hash"; WriteLog (lsFATAL, LedgerAcquire) << "We are acquiring a ledger with a zero account hash";
mHaveState = true; mHaveState = true;
} }
else else
@@ -187,11 +186,11 @@ bool LedgerAcquire::tryLocal()
{ {
AccountStateSF filter(mLedger->getLedgerSeq()); AccountStateSF filter(mLedger->getLedgerSeq());
mLedger->peekAccountStateMap()->fetchRoot(mLedger->getAccountHash(), &filter); mLedger->peekAccountStateMap()->fetchRoot(mLedger->getAccountHash(), &filter);
cLog(lsTRACE) << "Got root AS map locally"; WriteLog (lsTRACE, LedgerAcquire) << "Got root AS map locally";
std::vector<uint256> h = mLedger->getNeededAccountStateHashes(1, &filter); std::vector<uint256> h = mLedger->getNeededAccountStateHashes(1, &filter);
if (h.empty()) if (h.empty())
{ {
cLog(lsTRACE) << "Had full AS map locally"; WriteLog (lsTRACE, LedgerAcquire) << "Had full AS map locally";
mHaveState = true; mHaveState = true;
} }
} }
@@ -203,7 +202,7 @@ bool LedgerAcquire::tryLocal()
if (mHaveTransactions && mHaveState) if (mHaveTransactions && mHaveState)
{ {
cLog(lsDEBUG) << "Had everything locally"; WriteLog (lsDEBUG, LedgerAcquire) << "Had everything locally";
mComplete = true; mComplete = true;
mLedger->setClosed(); mLedger->setClosed();
mLedger->setImmutable(); mLedger->setImmutable();
@@ -219,7 +218,7 @@ void LedgerAcquire::onTimer(bool progress)
if (getTimeouts() > LEDGER_TIMEOUT_COUNT) if (getTimeouts() > LEDGER_TIMEOUT_COUNT)
{ {
cLog(lsWARNING) << "Too many timeouts( " << getTimeouts() << ") for ledger " << mHash; WriteLog (lsWARNING, LedgerAcquire) << "Too many timeouts( " << getTimeouts() << ") for ledger " << mHash;
setFailed(); setFailed();
done(); done();
return; return;
@@ -230,7 +229,7 @@ void LedgerAcquire::onTimer(bool progress)
mAggressive = true; mAggressive = true;
mByHash = true; mByHash = true;
int pc = getPeerCount(); int pc = getPeerCount();
cLog(lsDEBUG) << "No progress(" << pc << ") for ledger " << pc << mHash; WriteLog (lsDEBUG, LedgerAcquire) << "No progress(" << pc << ") for ledger " << pc << mHash;
if (pc == 0) if (pc == 0)
addPeers(); addPeers();
else else
@@ -300,7 +299,7 @@ void LedgerAcquire::done()
touch(); touch();
#ifdef LA_DEBUG #ifdef LA_DEBUG
cLog(lsTRACE) << "Done acquiring ledger " << mHash; WriteLog (lsTRACE, LedgerAcquire) << "Done acquiring ledger " << mHash;
#endif #endif
assert(isComplete() || isFailed()); assert(isComplete() || isFailed());
@@ -341,7 +340,7 @@ void LedgerAcquire::trigger(Peer::ref peer)
boost::recursive_mutex::scoped_lock sl(mLock); boost::recursive_mutex::scoped_lock sl(mLock);
if (isDone()) if (isDone())
{ {
cLog(lsDEBUG) << "Trigger on ledger: " << mHash << WriteLog (lsDEBUG, LedgerAcquire) << "Trigger on ledger: " << mHash <<
(mAborted ? " aborted": "") << (mComplete ? " completed": "") << (mFailed ? " failed" : ""); (mAborted ? " aborted": "") << (mComplete ? " completed": "") << (mFailed ? " failed" : "");
return; return;
} }
@@ -349,20 +348,20 @@ void LedgerAcquire::trigger(Peer::ref peer)
if ((mWaitCount > 0) && peer) if ((mWaitCount > 0) && peer)
{ {
mRecentPeers.push_back(peer->getPeerId()); mRecentPeers.push_back(peer->getPeerId());
cLog(lsTRACE) << "Deferring peer"; WriteLog (lsTRACE, LedgerAcquire) << "Deferring peer";
return; return;
} }
if (sLog(lsTRACE)) if (ShouldLog (lsTRACE, LedgerAcquire))
{ {
if (peer) if (peer)
cLog(lsTRACE) << "Trigger acquiring ledger " << mHash << " from " << peer->getIP(); WriteLog (lsTRACE, LedgerAcquire) << "Trigger acquiring ledger " << mHash << " from " << peer->getIP();
else else
cLog(lsTRACE) << "Trigger acquiring ledger " << mHash; WriteLog (lsTRACE, LedgerAcquire) << "Trigger acquiring ledger " << mHash;
if (mComplete || mFailed) if (mComplete || mFailed)
cLog(lsTRACE) << "complete=" << mComplete << " failed=" << mFailed; WriteLog (lsTRACE, LedgerAcquire) << "complete=" << mComplete << " failed=" << mFailed;
else else
cLog(lsTRACE) << "base=" << mHaveBase << " tx=" << mHaveTransactions << " as=" << mHaveState; WriteLog (lsTRACE, LedgerAcquire) << "base=" << mHaveBase << " tx=" << mHaveTransactions << " as=" << mHaveState;
} }
if (!mHaveBase) if (!mHaveBase)
@@ -370,7 +369,7 @@ void LedgerAcquire::trigger(Peer::ref peer)
tryLocal(); tryLocal();
if (mFailed) if (mFailed)
{ {
cLog(lsWARNING) << " failed local for " << mHash; WriteLog (lsWARNING, LedgerAcquire) << " failed local for " << mHash;
} }
} }
@@ -391,7 +390,7 @@ void LedgerAcquire::trigger(Peer::ref peer)
bool typeSet = false; bool typeSet = false;
BOOST_FOREACH(neededHash_t& p, need) BOOST_FOREACH(neededHash_t& p, need)
{ {
cLog(lsWARNING) << "Want: " << p.second; WriteLog (lsWARNING, LedgerAcquire) << "Want: " << p.second;
if (!typeSet) if (!typeSet)
{ {
tmBH.set_type(p.first); tmBH.set_type(p.first);
@@ -417,11 +416,11 @@ void LedgerAcquire::trigger(Peer::ref peer)
} }
} }
} }
cLog(lsINFO) << "Attempting by hash fetch for ledger " << mHash; WriteLog (lsINFO, LedgerAcquire) << "Attempting by hash fetch for ledger " << mHash;
} }
else else
{ {
cLog(lsINFO) << "getNeededHashes says acquire is complete"; WriteLog (lsINFO, LedgerAcquire) << "getNeededHashes says acquire is complete";
mHaveBase = true; mHaveBase = true;
mHaveTransactions = true; mHaveTransactions = true;
mHaveState = true; mHaveState = true;
@@ -433,7 +432,7 @@ void LedgerAcquire::trigger(Peer::ref peer)
if (!mHaveBase && !mFailed) if (!mHaveBase && !mFailed)
{ {
tmGL.set_itype(ripple::liBASE); tmGL.set_itype(ripple::liBASE);
cLog(lsTRACE) << "Sending base request to " << (peer ? "selected peer" : "all peers"); WriteLog (lsTRACE, LedgerAcquire) << "Sending base request to " << (peer ? "selected peer" : "all peers");
sendRequest(tmGL, peer); sendRequest(tmGL, peer);
return; return;
} }
@@ -448,7 +447,7 @@ void LedgerAcquire::trigger(Peer::ref peer)
{ // we need the root node { // we need the root node
tmGL.set_itype(ripple::liTX_NODE); tmGL.set_itype(ripple::liTX_NODE);
*(tmGL.add_nodeids()) = SHAMapNode().getRawString(); *(tmGL.add_nodeids()) = SHAMapNode().getRawString();
cLog(lsTRACE) << "Sending TX root request to " << (peer ? "selected peer" : "all peers"); WriteLog (lsTRACE, LedgerAcquire) << "Sending TX root request to " << (peer ? "selected peer" : "all peers");
sendRequest(tmGL, peer); sendRequest(tmGL, peer);
} }
else else
@@ -481,7 +480,7 @@ void LedgerAcquire::trigger(Peer::ref peer)
{ {
*(tmGL.add_nodeids()) = it.getRawString(); *(tmGL.add_nodeids()) = it.getRawString();
} }
cLog(lsTRACE) << "Sending TX node " << nodeIDs.size() WriteLog (lsTRACE, LedgerAcquire) << "Sending TX node " << nodeIDs.size()
<< " request to " << (peer ? "selected peer" : "all peers"); << " request to " << (peer ? "selected peer" : "all peers");
sendRequest(tmGL, peer); sendRequest(tmGL, peer);
} }
@@ -496,7 +495,7 @@ void LedgerAcquire::trigger(Peer::ref peer)
{ // we need the root node { // we need the root node
tmGL.set_itype(ripple::liAS_NODE); tmGL.set_itype(ripple::liAS_NODE);
*(tmGL.add_nodeids()) = SHAMapNode().getRawString(); *(tmGL.add_nodeids()) = SHAMapNode().getRawString();
cLog(lsTRACE) << "Sending AS root request to " << (peer ? "selected peer" : "all peers"); WriteLog (lsTRACE, LedgerAcquire) << "Sending AS root request to " << (peer ? "selected peer" : "all peers");
sendRequest(tmGL, peer); sendRequest(tmGL, peer);
} }
else else
@@ -527,9 +526,9 @@ void LedgerAcquire::trigger(Peer::ref peer)
tmGL.set_itype(ripple::liAS_NODE); tmGL.set_itype(ripple::liAS_NODE);
BOOST_FOREACH(SHAMapNode& it, nodeIDs) BOOST_FOREACH(SHAMapNode& it, nodeIDs)
*(tmGL.add_nodeids()) = it.getRawString(); *(tmGL.add_nodeids()) = it.getRawString();
cLog(lsTRACE) << "Sending AS node " << nodeIDs.size() WriteLog (lsTRACE, LedgerAcquire) << "Sending AS node " << nodeIDs.size()
<< " request to " << (peer ? "selected peer" : "all peers"); << " request to " << (peer ? "selected peer" : "all peers");
tLog(nodeIDs.size() == 1, lsTRACE) << "AS node: " << nodeIDs[0]; CondLog (nodeIDs.size() == 1, lsTRACE, LedgerAcquire) << "AS node: " << nodeIDs[0];
sendRequest(tmGL, peer); sendRequest(tmGL, peer);
} }
} }
@@ -540,7 +539,7 @@ void LedgerAcquire::trigger(Peer::ref peer)
if (mComplete || mFailed) if (mComplete || mFailed)
{ {
cLog(lsDEBUG) << "Done:" << (mComplete ? " complete" : "") << (mFailed ? " failed " : " ") WriteLog (lsDEBUG, LedgerAcquire) << "Done:" << (mComplete ? " complete" : "") << (mFailed ? " failed " : " ")
<< mLedger->getLedgerSeq(); << mLedger->getLedgerSeq();
sl.unlock(); sl.unlock();
done(); done();
@@ -631,7 +630,7 @@ void LedgerAcquire::filterNodes(std::vector<SHAMapNode>& nodeIDs, std::vector<ui
} }
++insertPoint; ++insertPoint;
} }
cLog(lsDEBUG) << "filterNodes " << nodeIDs.size() << " to " << insertPoint; WriteLog (lsDEBUG, LedgerAcquire) << "filterNodes " << nodeIDs.size() << " to " << insertPoint;
nodeIDs.resize(insertPoint); nodeIDs.resize(insertPoint);
nodeHashes.resize(insertPoint); nodeHashes.resize(insertPoint);
} }
@@ -649,7 +648,7 @@ void LedgerAcquire::filterNodes(std::vector<SHAMapNode>& nodeIDs, std::vector<ui
bool LedgerAcquire::takeBase(const std::string& data) // data must not have hash prefix bool LedgerAcquire::takeBase(const std::string& data) // data must not have hash prefix
{ // Return value: true=normal, false=bad data { // Return value: true=normal, false=bad data
#ifdef LA_DEBUG #ifdef LA_DEBUG
cLog(lsTRACE) << "got base acquiring ledger " << mHash; WriteLog (lsTRACE, LedgerAcquire) << "got base acquiring ledger " << mHash;
#endif #endif
boost::recursive_mutex::scoped_lock sl(mLock); boost::recursive_mutex::scoped_lock sl(mLock);
if (mComplete || mFailed || mHaveBase) if (mComplete || mFailed || mHaveBase)
@@ -657,8 +656,8 @@ bool LedgerAcquire::takeBase(const std::string& data) // data must not have hash
mLedger = boost::make_shared<Ledger>(data, false); mLedger = boost::make_shared<Ledger>(data, false);
if (mLedger->getHash() != mHash) if (mLedger->getHash() != mHash)
{ {
cLog(lsWARNING) << "Acquire hash mismatch"; WriteLog (lsWARNING, LedgerAcquire) << "Acquire hash mismatch";
cLog(lsWARNING) << mLedger->getHash() << "!=" << mHash; WriteLog (lsWARNING, LedgerAcquire) << mLedger->getHash() << "!=" << mHash;
mLedger.reset(); mLedger.reset();
#ifdef TRUST_NETWORK #ifdef TRUST_NETWORK
assert(false); assert(false);
@@ -725,13 +724,13 @@ bool LedgerAcquire::takeTxNode(const std::list<SHAMapNode>& nodeIDs,
bool LedgerAcquire::takeAsNode(const std::list<SHAMapNode>& nodeIDs, bool LedgerAcquire::takeAsNode(const std::list<SHAMapNode>& nodeIDs,
const std::list< std::vector<unsigned char> >& data, SMAddNode& san) const std::list< std::vector<unsigned char> >& data, SMAddNode& san)
{ {
cLog(lsTRACE) << "got ASdata (" << nodeIDs.size() <<") acquiring ledger " << mHash; WriteLog (lsTRACE, LedgerAcquire) << "got ASdata (" << nodeIDs.size() <<") acquiring ledger " << mHash;
tLog(nodeIDs.size() == 1, lsTRACE) << "got AS node: " << nodeIDs.front(); CondLog (nodeIDs.size() == 1, lsTRACE, LedgerAcquire) << "got AS node: " << nodeIDs.front();
boost::recursive_mutex::scoped_lock sl(mLock); boost::recursive_mutex::scoped_lock sl(mLock);
if (!mHaveBase) if (!mHaveBase)
{ {
cLog(lsWARNING) << "Don't have ledger base"; WriteLog (lsWARNING, LedgerAcquire) << "Don't have ledger base";
return false; return false;
} }
if (mHaveState || mFailed) if (mHaveState || mFailed)
@@ -747,13 +746,13 @@ bool LedgerAcquire::takeAsNode(const std::list<SHAMapNode>& nodeIDs,
if (!san.combine(mLedger->peekAccountStateMap()->addRootNode(mLedger->getAccountHash(), if (!san.combine(mLedger->peekAccountStateMap()->addRootNode(mLedger->getAccountHash(),
*nodeDatait, snfWIRE, &tFilter))) *nodeDatait, snfWIRE, &tFilter)))
{ {
cLog(lsWARNING) << "Bad ledger base"; WriteLog (lsWARNING, LedgerAcquire) << "Bad ledger base";
return false; return false;
} }
} }
else if (!san.combine(mLedger->peekAccountStateMap()->addKnownNode(*nodeIDit, *nodeDatait, &tFilter))) else if (!san.combine(mLedger->peekAccountStateMap()->addKnownNode(*nodeIDit, *nodeDatait, &tFilter)))
{ {
cLog(lsWARNING) << "Unable to add AS node"; WriteLog (lsWARNING, LedgerAcquire) << "Unable to add AS node";
return false; return false;
} }
++nodeIDit; ++nodeIDit;
@@ -818,7 +817,7 @@ LedgerAcquire::pointer LedgerAcquireMaster::findCreate(const uint256& hash, uint
ledger->setClosed(); ledger->setClosed();
ledger->setImmutable(); ledger->setImmutable();
theApp->getLedgerMaster().storeLedger(ledger); theApp->getLedgerMaster().storeLedger(ledger);
cLog(lsDEBUG) << "Acquiring ledger we already have: " << hash; WriteLog (lsDEBUG, LedgerAcquire) << "Acquiring ledger we already have: " << hash;
} }
return ptr; return ptr;
} }
@@ -923,12 +922,12 @@ void LedgerAcquireMaster::gotLedgerData(Job&, uint256 hash,
ripple::TMLedgerData& packet = *packet_ptr; ripple::TMLedgerData& packet = *packet_ptr;
Peer::pointer peer = wPeer.lock(); Peer::pointer peer = wPeer.lock();
cLog(lsTRACE) << "Got data (" << packet.nodes().size() << ") for acquiring ledger: " << hash; WriteLog (lsTRACE, LedgerAcquire) << "Got data (" << packet.nodes().size() << ") for acquiring ledger: " << hash;
LedgerAcquire::pointer ledger = find(hash); LedgerAcquire::pointer ledger = find(hash);
if (!ledger) if (!ledger)
{ {
cLog(lsTRACE) << "Got data for ledger we're not acquiring"; WriteLog (lsTRACE, LedgerAcquire) << "Got data for ledger we're not acquiring";
if (peer) if (peer)
peer->punishPeer(LT_InvalidRequest); peer->punishPeer(LT_InvalidRequest);
return; return;
@@ -942,24 +941,24 @@ void LedgerAcquireMaster::gotLedgerData(Job&, uint256 hash,
{ {
if (packet.nodes_size() < 1) if (packet.nodes_size() < 1)
{ {
cLog(lsWARNING) << "Got empty base data"; WriteLog (lsWARNING, LedgerAcquire) << "Got empty base data";
peer->punishPeer(LT_InvalidRequest); peer->punishPeer(LT_InvalidRequest);
return; return;
} }
if (!ledger->takeBase(packet.nodes(0).nodedata())) if (!ledger->takeBase(packet.nodes(0).nodedata()))
{ {
cLog(lsWARNING) << "Got invalid base data"; WriteLog (lsWARNING, LedgerAcquire) << "Got invalid base data";
peer->punishPeer(LT_InvalidRequest); peer->punishPeer(LT_InvalidRequest);
return; return;
} }
SMAddNode san = SMAddNode::useful(); SMAddNode san = SMAddNode::useful();
if ((packet.nodes().size() > 1) && !ledger->takeAsRootNode(strCopy(packet.nodes(1).nodedata()), san)) if ((packet.nodes().size() > 1) && !ledger->takeAsRootNode(strCopy(packet.nodes(1).nodedata()), san))
{ {
cLog(lsWARNING) << "Included ASbase invalid"; WriteLog (lsWARNING, LedgerAcquire) << "Included ASbase invalid";
} }
if ((packet.nodes().size() > 2) && !ledger->takeTxRootNode(strCopy(packet.nodes(2).nodedata()), san)) if ((packet.nodes().size() > 2) && !ledger->takeTxRootNode(strCopy(packet.nodes(2).nodedata()), san))
{ {
cLog(lsWARNING) << "Included TXbase invalid"; WriteLog (lsWARNING, LedgerAcquire) << "Included TXbase invalid";
} }
if (!san.isInvalid()) if (!san.isInvalid())
{ {
@@ -967,7 +966,7 @@ void LedgerAcquireMaster::gotLedgerData(Job&, uint256 hash,
ledger->trigger(peer); ledger->trigger(peer);
} }
else else
cLog(lsDEBUG) << "Peer sends invalid base data"; WriteLog (lsDEBUG, LedgerAcquire) << "Peer sends invalid base data";
return; return;
} }
@@ -978,7 +977,7 @@ void LedgerAcquireMaster::gotLedgerData(Job&, uint256 hash,
if (packet.nodes().size() <= 0) if (packet.nodes().size() <= 0)
{ {
cLog(lsINFO) << "Got response with no nodes"; WriteLog (lsINFO, LedgerAcquire) << "Got response with no nodes";
peer->punishPeer(LT_InvalidRequest); peer->punishPeer(LT_InvalidRequest);
return; return;
} }
@@ -987,7 +986,7 @@ void LedgerAcquireMaster::gotLedgerData(Job&, uint256 hash,
const ripple::TMLedgerNode& node = packet.nodes(i); const ripple::TMLedgerNode& node = packet.nodes(i);
if (!node.has_nodeid() || !node.has_nodedata()) if (!node.has_nodeid() || !node.has_nodedata())
{ {
cLog(lsWARNING) << "Got bad node"; WriteLog (lsWARNING, LedgerAcquire) << "Got bad node";
peer->punishPeer(LT_InvalidRequest); peer->punishPeer(LT_InvalidRequest);
return; return;
} }
@@ -1006,11 +1005,11 @@ void LedgerAcquireMaster::gotLedgerData(Job&, uint256 hash,
ledger->trigger(peer); ledger->trigger(peer);
} }
else else
cLog(lsDEBUG) << "Peer sends invalid node data"; WriteLog (lsDEBUG, LedgerAcquire) << "Peer sends invalid node data";
return; return;
} }
cLog(lsWARNING) << "Not sure what ledger data we got"; WriteLog (lsWARNING, LedgerAcquire) << "Not sure what ledger data we got";
peer->punishPeer(LT_InvalidRequest); peer->punishPeer(LT_InvalidRequest);
} }

167
src/cpp/ripple/LedgerConsensus.cpp
View File

@@ -24,7 +24,8 @@
typedef std::map<uint160, LedgerProposal::pointer>::value_type u160_prop_pair; typedef std::map<uint160, LedgerProposal::pointer>::value_type u160_prop_pair;
typedef std::map<uint256, LCTransaction::pointer>::value_type u256_lct_pair; typedef std::map<uint256, LCTransaction::pointer>::value_type u256_lct_pair;
SETUP_LOG(); class LedgerConensus;
DECLARE_INSTANCE(LedgerConsensus); DECLARE_INSTANCE(LedgerConsensus);
void LCTransaction::setVote(const uint160& peer, bool votesYes) void LCTransaction::setVote(const uint160& peer, bool votesYes)
@@ -36,25 +37,25 @@ void LCTransaction::setVote(const uint160& peer, bool votesYes)
{ // new vote { // new vote
if (votesYes) if (votesYes)
{ {
cLog(lsDEBUG) << "Peer " << peer << " votes YES on " << mTransactionID; WriteLog (lsDEBUG, LedgerConensus) << "Peer " << peer << " votes YES on " << mTransactionID;
++mYays; ++mYays;
} }
else else
{ {
cLog(lsDEBUG) << "Peer " << peer << " votes NO on " << mTransactionID; WriteLog (lsDEBUG, LedgerConensus) << "Peer " << peer << " votes NO on " << mTransactionID;
++mNays; ++mNays;
} }
} }
else if (votesYes && !res.first->second) else if (votesYes && !res.first->second)
{ // changes vote to yes { // changes vote to yes
cLog(lsDEBUG) << "Peer " << peer << " now votes YES on " << mTransactionID; WriteLog (lsDEBUG, LedgerConensus) << "Peer " << peer << " now votes YES on " << mTransactionID;
--mNays; --mNays;
++mYays; ++mYays;
res.first->second = true; res.first->second = true;
} }
else if (!votesYes && res.first->second) else if (!votesYes && res.first->second)
{ // changes vote to no { // changes vote to no
cLog(lsDEBUG) << "Peer " << peer << " now votes NO on " << mTransactionID; WriteLog (lsDEBUG, LedgerConensus) << "Peer " << peer << " now votes NO on " << mTransactionID;
++mNays; ++mNays;
--mYays; --mYays;
res.first->second = false; res.first->second = false;
@@ -106,15 +107,15 @@ bool LCTransaction::updateVote(int percentTime, bool proposing)
if (newPosition == mOurVote) if (newPosition == mOurVote)
{ {
cLog(lsINFO) << WriteLog (lsINFO, LedgerConensus) <<
"No change (" << (mOurVote ? "YES" : "NO") << ") : weight " << weight << ", percent " << percentTime; "No change (" << (mOurVote ? "YES" : "NO") << ") : weight " << weight << ", percent " << percentTime;
cLog(lsDEBUG) << getJson(); WriteLog (lsDEBUG, LedgerConensus) << getJson();
return false; return false;
} }
mOurVote = newPosition; mOurVote = newPosition;
cLog(lsDEBUG) << "We now vote " << (mOurVote ? "YES" : "NO") << " on " << mTransactionID; WriteLog (lsDEBUG, LedgerConensus) << "We now vote " << (mOurVote ? "YES" : "NO") << " on " << mTransactionID;
cLog(lsDEBUG) << getJson(); WriteLog (lsDEBUG, LedgerConensus) << getJson();
return true; return true;
} }
@@ -144,8 +145,8 @@ LedgerConsensus::LedgerConsensus(const uint256& prevLCLHash, Ledger::ref previou
mCurrentMSeconds(0), mClosePercent(0), mHaveCloseTimeConsensus(false), mCurrentMSeconds(0), mClosePercent(0), mHaveCloseTimeConsensus(false),
mConsensusStartTime(boost::posix_time::microsec_clock::universal_time()) mConsensusStartTime(boost::posix_time::microsec_clock::universal_time())
{ {
cLog(lsDEBUG) << "Creating consensus object"; WriteLog (lsDEBUG, LedgerConensus) << "Creating consensus object";
cLog(lsTRACE) << "LCL:" << previousLedger->getHash() <<", ct=" << closeTime; WriteLog (lsTRACE, LedgerConensus) << "LCL:" << previousLedger->getHash() <<", ct=" << closeTime;
mPreviousProposers = theApp->getOPs().getPreviousProposers(); mPreviousProposers = theApp->getOPs().getPreviousProposers();
mPreviousMSeconds = theApp->getOPs().getPreviousConvergeTime(); mPreviousMSeconds = theApp->getOPs().getPreviousConvergeTime();
assert(mPreviousMSeconds); assert(mPreviousMSeconds);
@@ -155,13 +156,13 @@ LedgerConsensus::LedgerConsensus(const uint256& prevLCLHash, Ledger::ref previou
if (mValPublic.isSet() && mValPrivate.isSet() && !theApp->getOPs().isNeedNetworkLedger()) if (mValPublic.isSet() && mValPrivate.isSet() && !theApp->getOPs().isNeedNetworkLedger())
{ {
cLog(lsINFO) << "Entering consensus process, validating"; WriteLog (lsINFO, LedgerConensus) << "Entering consensus process, validating";
mValidating = true; mValidating = true;
mProposing = theApp->getOPs().getOperatingMode() == NetworkOPs::omFULL; mProposing = theApp->getOPs().getOperatingMode() == NetworkOPs::omFULL;
} }
else else
{ {
cLog(lsINFO) << "Entering consensus process, watching"; WriteLog (lsINFO, LedgerConensus) << "Entering consensus process, watching";
mProposing = mValidating = false; mProposing = mValidating = false;
} }
@@ -173,8 +174,8 @@ LedgerConsensus::LedgerConsensus(const uint256& prevLCLHash, Ledger::ref previou
if (!mHaveCorrectLCL) if (!mHaveCorrectLCL)
{ {
// mProposing = mValidating = false; // mProposing = mValidating = false;
cLog(lsINFO) << "Entering consensus with: " << previousLedger->getHash(); WriteLog (lsINFO, LedgerConensus) << "Entering consensus with: " << previousLedger->getHash();
cLog(lsINFO) << "Correct LCL is: " << prevLCLHash; WriteLog (lsINFO, LedgerConensus) << "Correct LCL is: " << prevLCLHash;
} }
} }
else else
@@ -210,7 +211,7 @@ void LedgerConsensus::checkOurValidation()
boost::make_shared<PackedMessage>(val, ripple::mtVALIDATION)); boost::make_shared<PackedMessage>(val, ripple::mtVALIDATION));
#endif #endif
theApp->getOPs().setLastValidation(v); theApp->getOPs().setLastValidation(v);
cLog(lsWARNING) << "Sending partial validation"; WriteLog (lsWARNING, LedgerConensus) << "Sending partial validation";
} }
void LedgerConsensus::checkLCL() void LedgerConsensus::checkLCL()
@@ -246,15 +247,15 @@ void LedgerConsensus::checkLCL()
default: status = "unknown"; default: status = "unknown";
} }
cLog(lsWARNING) << "View of consensus changed during " << status << " (" << netLgrCount << ") status=" WriteLog (lsWARNING, LedgerConensus) << "View of consensus changed during " << status << " (" << netLgrCount << ") status="
<< status << ", " << (mHaveCorrectLCL ? "CorrectLCL" : "IncorrectLCL"); << status << ", " << (mHaveCorrectLCL ? "CorrectLCL" : "IncorrectLCL");
cLog(lsWARNING) << mPrevLedgerHash << " to " << netLgr; WriteLog (lsWARNING, LedgerConensus) << mPrevLedgerHash << " to " << netLgr;
cLog(lsWARNING) << mPreviousLedger->getJson(0); WriteLog (lsWARNING, LedgerConensus) << mPreviousLedger->getJson(0);
if (sLog(lsDEBUG)) if (ShouldLog (lsDEBUG, LedgerConensus))
{ {
BOOST_FOREACH(u256_cvc_pair& it, vals) BOOST_FOREACH(u256_cvc_pair& it, vals)
cLog(lsDEBUG) << "V: " << it.first << ", " << it.second.first; WriteLog (lsDEBUG, LedgerConensus) << "V: " << it.first << ", " << it.second.first;
} }
if (mHaveCorrectLCL) if (mHaveCorrectLCL)
@@ -274,7 +275,7 @@ void LedgerConsensus::handleLCL(const uint256& lclHash)
if (mHaveCorrectLCL && mProposing && mOurPosition) if (mHaveCorrectLCL && mProposing && mOurPosition)
{ {
cLog(lsINFO) << "Bowing out of consensus"; WriteLog (lsINFO, LedgerConensus) << "Bowing out of consensus";
mOurPosition->bowOut(); mOurPosition->bowOut();
propose(); propose();
} }
@@ -302,7 +303,7 @@ void LedgerConsensus::handleLCL(const uint256& lclHash)
} }
else if (!mAcquiringLedger || (mAcquiringLedger->getHash() != mPrevLedgerHash)) else if (!mAcquiringLedger || (mAcquiringLedger->getHash() != mPrevLedgerHash))
{ // need to start acquiring the correct consensus LCL { // need to start acquiring the correct consensus LCL
cLog(lsWARNING) << "Need consensus ledger " << mPrevLedgerHash; WriteLog (lsWARNING, LedgerConensus) << "Need consensus ledger " << mPrevLedgerHash;
if (mAcquiringLedger) if (mAcquiringLedger)
theApp->getMasterLedgerAcquire().dropLedger(mAcquiringLedger->getHash()); theApp->getMasterLedgerAcquire().dropLedger(mAcquiringLedger->getHash());
mAcquiringLedger = theApp->getMasterLedgerAcquire().findCreate(mPrevLedgerHash, 0); mAcquiringLedger = theApp->getMasterLedgerAcquire().findCreate(mPrevLedgerHash, 0);
@@ -310,7 +311,7 @@ void LedgerConsensus::handleLCL(const uint256& lclHash)
return; return;
} }
cLog(lsINFO) << "Have the consensus ledger " << mPrevLedgerHash; WriteLog (lsINFO, LedgerConensus) << "Have the consensus ledger " << mPrevLedgerHash;
mHaveCorrectLCL = true; mHaveCorrectLCL = true;
mCloseResolution = ContinuousLedgerTiming::getNextLedgerTimeResolution( mCloseResolution = ContinuousLedgerTiming::getNextLedgerTimeResolution(
@@ -333,7 +334,7 @@ void LedgerConsensus::takeInitialPosition(Ledger& initialLedger)
else else
initialSet = initialLedger.peekTransactionMap()->snapShot(false); initialSet = initialLedger.peekTransactionMap()->snapShot(false);
uint256 txSet = initialSet->getHash(); uint256 txSet = initialSet->getHash();
cLog(lsINFO) << "initial position " << txSet; WriteLog (lsINFO, LedgerConensus) << "initial position " << txSet;
mapComplete(txSet, initialSet, false); mapComplete(txSet, initialSet, false);
if (mValidating) if (mValidating)
@@ -401,13 +402,13 @@ void LedgerConsensus::createDisputes(SHAMap::ref m1, SHAMap::ref m2)
void LedgerConsensus::mapComplete(const uint256& hash, SHAMap::ref map, bool acquired) void LedgerConsensus::mapComplete(const uint256& hash, SHAMap::ref map, bool acquired)
{ {
tLog(acquired, lsINFO) << "We have acquired TXS " << hash; CondLog (acquired, lsINFO, LedgerConensus) << "We have acquired TXS " << hash;
if (!map) if (!map)
{ // this is an invalid/corrupt map { // this is an invalid/corrupt map
mAcquired[hash] = map; mAcquired[hash] = map;
mAcquiring.erase(hash); mAcquiring.erase(hash);
cLog(lsWARNING) << "A trusted node directed us to acquire an invalid TXN map"; WriteLog (lsWARNING, LedgerConensus) << "A trusted node directed us to acquire an invalid TXN map";
return; return;
} }
assert(hash == map->getHash()); assert(hash == map->getHash());
@@ -450,7 +451,7 @@ void LedgerConsensus::mapComplete(const uint256& hash, SHAMap::ref map, bool acq
adjustCount(map, peers); adjustCount(map, peers);
else else
{ {
tLog(acquired, lsWARNING) << "By the time we got the map " << hash << " no peers were proposing it"; CondLog (acquired, lsWARNING, LedgerConensus) << "By the time we got the map " << hash << " no peers were proposing it";
} }
sendHaveTxSet(hash, true); sendHaveTxSet(hash, true);
@@ -496,7 +497,7 @@ void LedgerConsensus::statusChange(ripple::NodeEvent event, Ledger& ledger)
PackedMessage::pointer packet = boost::make_shared<PackedMessage>(s, ripple::mtSTATUS_CHANGE); PackedMessage::pointer packet = boost::make_shared<PackedMessage>(s, ripple::mtSTATUS_CHANGE);
theApp->getConnectionPool().relayMessage(NULL, packet); theApp->getConnectionPool().relayMessage(NULL, packet);
cLog(lsTRACE) << "send status change to peer"; WriteLog (lsTRACE, LedgerConensus) << "send status change to peer";
} }
int LedgerConsensus::startup() int LedgerConsensus::startup()
@@ -552,11 +553,11 @@ void LedgerConsensus::stateEstablish()
updateOurPositions(); updateOurPositions();
if (!mHaveCloseTimeConsensus) if (!mHaveCloseTimeConsensus)
{ {
tLog(haveConsensus(false), lsINFO) << "We have TX consensus but not CT consensus"; CondLog (haveConsensus(false), lsINFO, LedgerConensus) << "We have TX consensus but not CT consensus";
} }
else if (haveConsensus(true)) else if (haveConsensus(true))
{ {
cLog(lsINFO) << "Converge cutoff (" << mPeerPositions.size() << " participants)"; WriteLog (lsINFO, LedgerConensus) << "Converge cutoff (" << mPeerPositions.size() << " participants)";
mState = lcsFINISHED; mState = lcsFINISHED;
beginAccept(false); beginAccept(false);
} }
@@ -579,7 +580,7 @@ void LedgerConsensus::timerEntry()
{ {
if (doShutdown) if (doShutdown)
{ {
cLog(lsFATAL) << "Shutdown requested"; WriteLog (lsFATAL, LedgerConensus) << "Shutdown requested";
theApp->stop(); theApp->stop();
} }
@@ -618,7 +619,7 @@ void LedgerConsensus::updateOurPositions()
if (it->second->isStale(peerCutoff)) if (it->second->isStale(peerCutoff))
{ // proposal is stale { // proposal is stale
uint160 peerID = it->second->getPeerID(); uint160 peerID = it->second->getPeerID();
cLog(lsWARNING) << "Removing stale proposal from " << peerID; WriteLog (lsWARNING, LedgerConensus) << "Removing stale proposal from " << peerID;
BOOST_FOREACH(u256_lct_pair& it, mDisputes) BOOST_FOREACH(u256_lct_pair& it, mDisputes)
it.second->unVote(peerID); it.second->unVote(peerID);
it = mPeerPositions.erase(it); it = mPeerPositions.erase(it);
@@ -690,23 +691,23 @@ void LedgerConsensus::updateOurPositions()
threshVote = 1; threshVote = 1;
if (threshConsensus == 0) if (threshConsensus == 0)
threshConsensus = 1; threshConsensus = 1;
cLog(lsINFO) << "Proposers:" << mPeerPositions.size() << " nw:" << neededWeight WriteLog (lsINFO, LedgerConensus) << "Proposers:" << mPeerPositions.size() << " nw:" << neededWeight
<< " thrV:" << threshVote << " thrC:" << threshConsensus; << " thrV:" << threshVote << " thrC:" << threshConsensus;
for (std::map<uint32, int>::iterator it = closeTimes.begin(), end = closeTimes.end(); it != end; ++it) for (std::map<uint32, int>::iterator it = closeTimes.begin(), end = closeTimes.end(); it != end; ++it)
{ {
cLog(lsDEBUG) << "CCTime: seq" << mPreviousLedger->getLedgerSeq() + 1 << ": " << WriteLog (lsDEBUG, LedgerConensus) << "CCTime: seq" << mPreviousLedger->getLedgerSeq() + 1 << ": " <<
it->first << " has " << it->second << ", " << threshVote << " required"; it->first << " has " << it->second << ", " << threshVote << " required";
if (it->second >= threshVote) if (it->second >= threshVote)
{ {
cLog(lsDEBUG) << "Close time consensus reached: " << it->first; WriteLog (lsDEBUG, LedgerConensus) << "Close time consensus reached: " << it->first;
closeTime = it->first; closeTime = it->first;
threshVote = it->second; threshVote = it->second;
if (threshVote >= threshConsensus) if (threshVote >= threshConsensus)
mHaveCloseTimeConsensus = true; mHaveCloseTimeConsensus = true;
} }
} }
tLog(!mHaveCloseTimeConsensus, lsDEBUG) << "No CT consensus: Proposers:" << mPeerPositions.size() CondLog (!mHaveCloseTimeConsensus, lsDEBUG, LedgerConensus) << "No CT consensus: Proposers:" << mPeerPositions.size()
<< " Proposing:" << (mProposing ? "yes" : "no") << " Thresh:" << threshConsensus << " Pos:" << closeTime; << " Proposing:" << (mProposing ? "yes" : "no") << " Thresh:" << threshConsensus << " Pos:" << closeTime;
} }
@@ -722,7 +723,7 @@ void LedgerConsensus::updateOurPositions()
if (changes) if (changes)
{ {
uint256 newHash = ourPosition->getHash(); uint256 newHash = ourPosition->getHash();
cLog(lsINFO) << "Position change: CTime " << closeTime << ", tx " << newHash; WriteLog (lsINFO, LedgerConensus) << "Position change: CTime " << closeTime << ", tx " << newHash;
if (mOurPosition->changePosition(newHash, closeTime)) if (mOurPosition->changePosition(newHash, closeTime))
{ {
if (mProposing) if (mProposing)
@@ -744,14 +745,14 @@ bool LedgerConsensus::haveConsensus(bool forReal)
++agree; ++agree;
else else
{ {
cLog(lsDEBUG) << it.first.GetHex() << " has " << it.second->getCurrentHash().GetHex(); WriteLog (lsDEBUG, LedgerConensus) << it.first.GetHex() << " has " << it.second->getCurrentHash().GetHex();
++disagree; ++disagree;
} }
} }
} }
int currentValidations = theApp->getValidations().getNodesAfter(mPrevLedgerHash); int currentValidations = theApp->getValidations().getNodesAfter(mPrevLedgerHash);
cLog(lsDEBUG) << "Checking for TX consensus: agree=" << agree << ", disagree=" << disagree; WriteLog (lsDEBUG, LedgerConensus) << "Checking for TX consensus: agree=" << agree << ", disagree=" << disagree;
return ContinuousLedgerTiming::haveConsensus(mPreviousProposers, agree + disagree, agree, currentValidations, return ContinuousLedgerTiming::haveConsensus(mPreviousProposers, agree + disagree, agree, currentValidations,
mPreviousMSeconds, mCurrentMSeconds, forReal, mConsensusFail); mPreviousMSeconds, mCurrentMSeconds, forReal, mConsensusFail);
@@ -826,7 +827,7 @@ void LedgerConsensus::startAcquiring(TransactionAcquire::pointer acquire)
void LedgerConsensus::propose() void LedgerConsensus::propose()
{ {
cLog(lsTRACE) << "We propose: " << WriteLog (lsTRACE, LedgerConensus) << "We propose: " <<
(mOurPosition->isBowOut() ? std::string("bowOut") : mOurPosition->getCurrentHash().GetHex()); (mOurPosition->isBowOut() ? std::string("bowOut") : mOurPosition->getCurrentHash().GetHex());
ripple::TMProposeSet prop; ripple::TMProposeSet prop;
@@ -847,7 +848,7 @@ void LedgerConsensus::addDisputedTransaction(const uint256& txID, const std::vec
{ {
if (mDisputes.find(txID) != mDisputes.end()) if (mDisputes.find(txID) != mDisputes.end())
return; return;
cLog(lsDEBUG) << "Transaction " << txID << " is disputed"; WriteLog (lsDEBUG, LedgerConensus) << "Transaction " << txID << " is disputed";
bool ourVote = false; bool ourVote = false;
if (mOurPosition) if (mOurPosition)
@@ -886,7 +887,7 @@ bool LedgerConsensus::peerPosition(LedgerProposal::ref newPosition)
uint160 peerID = newPosition->getPeerID(); uint160 peerID = newPosition->getPeerID();
if (mDeadNodes.find(peerID) != mDeadNodes.end()) if (mDeadNodes.find(peerID) != mDeadNodes.end())
{ {
cLog(lsINFO) << "Position from dead node: " << peerID.GetHex(); WriteLog (lsINFO, LedgerConensus) << "Position from dead node: " << peerID.GetHex();
return false; return false;
} }
@@ -901,12 +902,12 @@ bool LedgerConsensus::peerPosition(LedgerProposal::ref newPosition)
if (newPosition->getProposeSeq() == 0) if (newPosition->getProposeSeq() == 0)
{ // new initial close time estimate { // new initial close time estimate
cLog(lsTRACE) << "Peer reports close time as " << newPosition->getCloseTime(); WriteLog (lsTRACE, LedgerConensus) << "Peer reports close time as " << newPosition->getCloseTime();
++mCloseTimes[newPosition->getCloseTime()]; ++mCloseTimes[newPosition->getCloseTime()];
} }
else if (newPosition->getProposeSeq() == LedgerProposal::seqLeave) else if (newPosition->getProposeSeq() == LedgerProposal::seqLeave)
{ // peer bows out { // peer bows out
cLog(lsINFO) << "Peer bows out: " << peerID.GetHex(); WriteLog (lsINFO, LedgerConensus) << "Peer bows out: " << peerID.GetHex();
BOOST_FOREACH(u256_lct_pair& it, mDisputes) BOOST_FOREACH(u256_lct_pair& it, mDisputes)
it.second->unVote(peerID); it.second->unVote(peerID);
mPeerPositions.erase(peerID); mPeerPositions.erase(peerID);
@@ -915,7 +916,7 @@ bool LedgerConsensus::peerPosition(LedgerProposal::ref newPosition)
} }
cLog(lsTRACE) << "Processing peer proposal " WriteLog (lsTRACE, LedgerConensus) << "Processing peer proposal "
<< newPosition->getProposeSeq() << "/" << newPosition->getCurrentHash(); << newPosition->getProposeSeq() << "/" << newPosition->getCurrentHash();
currentPosition = newPosition; currentPosition = newPosition;
@@ -927,7 +928,7 @@ bool LedgerConsensus::peerPosition(LedgerProposal::ref newPosition)
} }
else else
{ {
cLog(lsDEBUG) << "Don't have tx set for peer"; WriteLog (lsDEBUG, LedgerConensus) << "Don't have tx set for peer";
// BOOST_FOREACH(u256_lct_pair& it, mDisputes) // BOOST_FOREACH(u256_lct_pair& it, mDisputes)
// it.second->unVote(peerID); // it.second->unVote(peerID);
} }
@@ -961,7 +962,7 @@ SMAddNode LedgerConsensus::peerGaveNodes(Peer::ref peer, const uint256& setHash,
boost::unordered_map<uint256, TransactionAcquire::pointer>::iterator acq = mAcquiring.find(setHash); boost::unordered_map<uint256, TransactionAcquire::pointer>::iterator acq = mAcquiring.find(setHash);
if (acq == mAcquiring.end()) if (acq == mAcquiring.end())
{ {
cLog(lsDEBUG) << "Got TX data for set no longer acquiring: " << setHash; WriteLog (lsDEBUG, LedgerConensus) << "Got TX data for set no longer acquiring: " << setHash;
return SMAddNode(); return SMAddNode();
} }
TransactionAcquire::pointer set = acq->second; // We must keep the set around during the function TransactionAcquire::pointer set = acq->second; // We must keep the set around during the function
@@ -973,7 +974,7 @@ void LedgerConsensus::beginAccept(bool synchronous)
SHAMap::pointer consensusSet = mAcquired[mOurPosition->getCurrentHash()]; SHAMap::pointer consensusSet = mAcquired[mOurPosition->getCurrentHash()];
if (!consensusSet) if (!consensusSet)
{ {
cLog(lsFATAL) << "We don't have a consensus set"; WriteLog (lsFATAL, LedgerConensus) << "We don't have a consensus set";
abort(); abort();
return; return;
} }
@@ -1003,7 +1004,7 @@ void LedgerConsensus::playbackProposals()
proposal->setPrevLedger(mPrevLedgerHash); proposal->setPrevLedger(mPrevLedgerHash);
if (proposal->checkSign()) if (proposal->checkSign())
{ {
cLog(lsINFO) << "Applying stored proposal"; WriteLog (lsINFO, LedgerConensus) << "Applying stored proposal";
relay = peerPosition(proposal); relay = peerPosition(proposal);
} }
} }
@@ -1012,13 +1013,13 @@ void LedgerConsensus::playbackProposals()
if (relay) if (relay)
{ {
cLog(lsWARNING) << "We should do delayed relay of this proposal, but we cannot"; WriteLog (lsWARNING, LedgerConensus) << "We should do delayed relay of this proposal, but we cannot";
} }
#if 0 // FIXME: We can't do delayed relay because we don't have the signature #if 0 // FIXME: We can't do delayed relay because we don't have the signature
std::set<uint64> peers std::set<uint64> peers
if (relay && theApp->getSuppression().swapSet(proposal.getSuppress(), set, SF_RELAYED)) if (relay && theApp->getSuppression().swapSet(proposal.getSuppress(), set, SF_RELAYED))
{ {
cLog(lsDEBUG) << "Stored proposal delayed relay"; WriteLog (lsDEBUG, LedgerConensus) << "Stored proposal delayed relay";
ripple::TMProposeSet set; ripple::TMProposeSet set;
set.set_proposeseq set.set_proposeseq
set.set_currenttxhash(, 256 / 8); set.set_currenttxhash(, 256 / 8);
@@ -1047,10 +1048,10 @@ int LedgerConsensus::applyTransaction(TransactionEngine& engine, SerializedTrans
if (theApp->isNewFlag(txn->getTransactionID(), SF_SIGGOOD)) if (theApp->isNewFlag(txn->getTransactionID(), SF_SIGGOOD))
parms = static_cast<TransactionEngineParams>(parms | tapNO_CHECK_SIGN); parms = static_cast<TransactionEngineParams>(parms | tapNO_CHECK_SIGN);
cLog(lsDEBUG) << "TXN " << txn->getTransactionID() WriteLog (lsDEBUG, LedgerConensus) << "TXN " << txn->getTransactionID()
<< (openLedger ? " open" : " closed") << (openLedger ? " open" : " closed")
<< (retryAssured ? "/retry" : "/final"); << (retryAssured ? "/retry" : "/final");
cLog(lsTRACE) << txn->getJson(0); WriteLog (lsTRACE, LedgerConensus) << txn->getJson(0);
#ifndef TRUST_NETWORK #ifndef TRUST_NETWORK
try try
@@ -1061,17 +1062,17 @@ int LedgerConsensus::applyTransaction(TransactionEngine& engine, SerializedTrans
TER result = engine.applyTransaction(*txn, parms, didApply); TER result = engine.applyTransaction(*txn, parms, didApply);
if (didApply) if (didApply)
{ {
cLog(lsDEBUG) << "Transaction success: " << transHuman(result); WriteLog (lsDEBUG, LedgerConensus) << "Transaction success: " << transHuman(result);
return LCAT_SUCCESS; return LCAT_SUCCESS;
} }
if (isTefFailure(result) || isTemMalformed(result) || isTelLocal(result)) if (isTefFailure(result) || isTemMalformed(result) || isTelLocal(result))
{ // failure { // failure
cLog(lsDEBUG) << "Transaction failure: " << transHuman(result); WriteLog (lsDEBUG, LedgerConensus) << "Transaction failure: " << transHuman(result);
return LCAT_FAIL; return LCAT_FAIL;
} }
cLog(lsDEBUG) << "Transaction retry: " << transHuman(result); WriteLog (lsDEBUG, LedgerConensus) << "Transaction retry: " << transHuman(result);
assert(!ledger->hasTransaction(txn->getTransactionID())); assert(!ledger->hasTransaction(txn->getTransactionID()));
return LCAT_RETRY; return LCAT_RETRY;
@@ -1079,7 +1080,7 @@ int LedgerConsensus::applyTransaction(TransactionEngine& engine, SerializedTrans
} }
catch (...) catch (...)
{ {
cLog(lsWARNING) << "Throws"; WriteLog (lsWARNING, LedgerConensus) << "Throws";
return false; return false;
} }
#endif #endif
@@ -1093,7 +1094,7 @@ void LedgerConsensus::applyTransactions(SHAMap::ref set, Ledger::ref applyLedger
for (SHAMapItem::pointer item = set->peekFirstItem(); !!item; item = set->peekNextItem(item->getTag())) for (SHAMapItem::pointer item = set->peekFirstItem(); !!item; item = set->peekNextItem(item->getTag()))
if (!checkLedger->hasTransaction(item->getTag())) if (!checkLedger->hasTransaction(item->getTag()))
{ {
cLog(lsINFO) << "Processing candidate transaction: " << item->getTag(); WriteLog (lsINFO, LedgerConensus) << "Processing candidate transaction: " << item->getTag();
#ifndef TRUST_NETWORK #ifndef TRUST_NETWORK
try try
{ {
@@ -1106,7 +1107,7 @@ void LedgerConsensus::applyTransactions(SHAMap::ref set, Ledger::ref applyLedger
} }
catch (...) catch (...)
{ {
cLog(lsWARNING) << " Throws"; WriteLog (lsWARNING, LedgerConensus) << " Throws";
} }
#endif #endif
} }
@@ -1116,7 +1117,7 @@ void LedgerConsensus::applyTransactions(SHAMap::ref set, Ledger::ref applyLedger
for (int pass = 0; pass < LEDGER_TOTAL_PASSES; ++pass) for (int pass = 0; pass < LEDGER_TOTAL_PASSES; ++pass)
{ {
cLog(lsDEBUG) << "Pass: " << pass << " Txns: " << failedTransactions.size() WriteLog (lsDEBUG, LedgerConensus) << "Pass: " << pass << " Txns: " << failedTransactions.size()
<< (certainRetry ? " retriable" : " final"); << (certainRetry ? " retriable" : " final");
changes = 0; changes = 0;
@@ -1142,11 +1143,11 @@ void LedgerConsensus::applyTransactions(SHAMap::ref set, Ledger::ref applyLedger
} }
catch (...) catch (...)
{ {
cLog(lsWARNING) << "Transaction throws"; WriteLog (lsWARNING, LedgerConensus) << "Transaction throws";
it = failedTransactions.erase(it); it = failedTransactions.erase(it);
} }
} }
cLog(lsDEBUG) << "Pass: " << pass << " finished " << changes << " changes"; WriteLog (lsDEBUG, LedgerConensus) << "Pass: " << pass << " finished " << changes << " changes";
// A non-retry pass made no changes // A non-retry pass made no changes
if (!changes && !certainRetry) if (!changes && !certainRetry)
@@ -1179,10 +1180,10 @@ void LedgerConsensus::accept(SHAMap::ref set, LoadEvent::pointer)
closeTime = mPreviousLedger->getCloseTimeNC() + 1; closeTime = mPreviousLedger->getCloseTimeNC() + 1;
} }
cLog(lsDEBUG) << "Report: Prop=" << (mProposing ? "yes" : "no") << " val=" << (mValidating ? "yes" : "no") << WriteLog (lsDEBUG, LedgerConensus) << "Report: Prop=" << (mProposing ? "yes" : "no") << " val=" << (mValidating ? "yes" : "no") <<
" corLCL=" << (mHaveCorrectLCL ? "yes" : "no") << " fail="<< (mConsensusFail ? "yes" : "no"); " corLCL=" << (mHaveCorrectLCL ? "yes" : "no") << " fail="<< (mConsensusFail ? "yes" : "no");
cLog(lsDEBUG) << "Report: Prev = " << mPrevLedgerHash << ":" << mPreviousLedger->getLedgerSeq(); WriteLog (lsDEBUG, LedgerConensus) << "Report: Prev = " << mPrevLedgerHash << ":" << mPreviousLedger->getLedgerSeq();
cLog(lsDEBUG) << "Report: TxSt = " << set->getHash() << ", close " << closeTime << (closeTimeCorrect ? "" : "X"); WriteLog (lsDEBUG, LedgerConensus) << "Report: TxSt = " << set->getHash() << ", close " << closeTime << (closeTimeCorrect ? "" : "X");
CanonicalTXSet failedTransactions(set->getHash()); CanonicalTXSet failedTransactions(set->getHash());
@@ -1190,7 +1191,7 @@ void LedgerConsensus::accept(SHAMap::ref set, LoadEvent::pointer)
newLCL->peekTransactionMap()->armDirty(); newLCL->peekTransactionMap()->armDirty();
newLCL->peekAccountStateMap()->armDirty(); newLCL->peekAccountStateMap()->armDirty();
cLog(lsDEBUG) << "Applying consensus set transactions to the last closed ledger"; WriteLog (lsDEBUG, LedgerConensus) << "Applying consensus set transactions to the last closed ledger";
applyTransactions(set, newLCL, newLCL, failedTransactions, false); applyTransactions(set, newLCL, newLCL, failedTransactions, false);
newLCL->updateSkipList(); newLCL->updateSkipList();
newLCL->setClosed(); newLCL->setClosed();
@@ -1200,23 +1201,23 @@ void LedgerConsensus::accept(SHAMap::ref set, LoadEvent::pointer)
// write out dirty nodes (temporarily done here) Most come before setAccepted // write out dirty nodes (temporarily done here) Most come before setAccepted
int fc; int fc;
while ((fc = SHAMap::flushDirty(*acctNodes, 256, hotACCOUNT_NODE, newLCL->getLedgerSeq())) > 0) while ((fc = SHAMap::flushDirty(*acctNodes, 256, hotACCOUNT_NODE, newLCL->getLedgerSeq())) > 0)
{ cLog(lsTRACE) << "Flushed " << fc << " dirty state nodes"; } { WriteLog (lsTRACE, LedgerConensus) << "Flushed " << fc << " dirty state nodes"; }
while ((fc = SHAMap::flushDirty(*txnNodes, 256, hotTRANSACTION_NODE, newLCL->getLedgerSeq())) > 0) while ((fc = SHAMap::flushDirty(*txnNodes, 256, hotTRANSACTION_NODE, newLCL->getLedgerSeq())) > 0)
{ cLog(lsTRACE) << "Flushed " << fc << " dirty transaction nodes"; } { WriteLog (lsTRACE, LedgerConensus) << "Flushed " << fc << " dirty transaction nodes"; }
newLCL->setAccepted(closeTime, mCloseResolution, closeTimeCorrect); newLCL->setAccepted(closeTime, mCloseResolution, closeTimeCorrect);
newLCL->updateHash(); newLCL->updateHash();
newLCL->setImmutable(); newLCL->setImmutable();
cLog(lsDEBUG) << "Report: NewL = " << newLCL->getHash() << ":" << newLCL->getLedgerSeq(); WriteLog (lsDEBUG, LedgerConensus) << "Report: NewL = " << newLCL->getHash() << ":" << newLCL->getLedgerSeq();
uint256 newLCLHash = newLCL->getHash(); uint256 newLCLHash = newLCL->getHash();
if (sLog(lsTRACE)) if (ShouldLog (lsTRACE, LedgerConensus))
{ {
cLog(lsTRACE) << "newLCL"; WriteLog (lsTRACE, LedgerConensus) << "newLCL";
Json::Value p; Json::Value p;
newLCL->addJson(p, LEDGER_JSON_DUMP_TXRP | LEDGER_JSON_DUMP_STATE); newLCL->addJson(p, LEDGER_JSON_DUMP_TXRP | LEDGER_JSON_DUMP_STATE);
cLog(lsTRACE) << p; WriteLog (lsTRACE, LedgerConensus) << p;
} }
statusChange(ripple::neACCEPTED_LEDGER, *newLCL); statusChange(ripple::neACCEPTED_LEDGER, *newLCL);
@@ -1241,10 +1242,10 @@ void LedgerConsensus::accept(SHAMap::ref set, LoadEvent::pointer)
val.set_validation(&validation[0], validation.size()); val.set_validation(&validation[0], validation.size());
int j = theApp->getConnectionPool().relayMessage(NULL, int j = theApp->getConnectionPool().relayMessage(NULL,
boost::make_shared<PackedMessage>(val, ripple::mtVALIDATION)); boost::make_shared<PackedMessage>(val, ripple::mtVALIDATION));
cLog(lsINFO) << "CNF Val " << newLCLHash << " to " << j << " peers"; WriteLog (lsINFO, LedgerConensus) << "CNF Val " << newLCLHash << " to " << j << " peers";
} }
else else
cLog(lsINFO) << "CNF newLCL " << newLCLHash; WriteLog (lsINFO, LedgerConensus) << "CNF newLCL " << newLCLHash;
Ledger::pointer newOL = boost::make_shared<Ledger>(true, boost::ref(*newLCL)); Ledger::pointer newOL = boost::make_shared<Ledger>(true, boost::ref(*newLCL));
ScopedLock sl( theApp->getLedgerMaster().getLock()); ScopedLock sl( theApp->getLedgerMaster().getLock());
@@ -1257,7 +1258,7 @@ void LedgerConsensus::accept(SHAMap::ref set, LoadEvent::pointer)
{ // we voted NO { // we voted NO
try try
{ {
cLog(lsDEBUG) << "Test applying disputed transaction that did not get in"; WriteLog (lsDEBUG, LedgerConensus) << "Test applying disputed transaction that did not get in";
SerializerIterator sit(it.second->peekTransaction()); SerializerIterator sit(it.second->peekTransaction());
SerializedTransaction::pointer txn = boost::make_shared<SerializedTransaction>(boost::ref(sit)); SerializedTransaction::pointer txn = boost::make_shared<SerializedTransaction>(boost::ref(sit));
if (applyTransaction(engine, txn, newOL, true, false)) if (applyTransaction(engine, txn, newOL, true, false))
@@ -1265,12 +1266,12 @@ void LedgerConsensus::accept(SHAMap::ref set, LoadEvent::pointer)
} }
catch (...) catch (...)
{ {
cLog(lsDEBUG) << "Failed to apply transaction we voted NO on"; WriteLog (lsDEBUG, LedgerConensus) << "Failed to apply transaction we voted NO on";
} }
} }
} }
cLog(lsDEBUG) << "Applying transactions from current open ledger"; WriteLog (lsDEBUG, LedgerConensus) << "Applying transactions from current open ledger";
applyTransactions(theApp->getLedgerMaster().getCurrentLedger()->peekTransactionMap(), newOL, newLCL, applyTransactions(theApp->getLedgerMaster().getCurrentLedger()->peekTransactionMap(), newOL, newLCL,
failedTransactions, true); failedTransactions, true);
theApp->getLedgerMaster().pushLedger(newLCL, newOL, !mConsensusFail); theApp->getLedgerMaster().pushLedger(newLCL, newOL, !mConsensusFail);
@@ -1280,12 +1281,12 @@ void LedgerConsensus::accept(SHAMap::ref set, LoadEvent::pointer)
if (mValidating) if (mValidating)
{ // see how close our close time is to other node's close time reports { // see how close our close time is to other node's close time reports
cLog(lsINFO) << "We closed at " << boost::lexical_cast<std::string>(mCloseTime); WriteLog (lsINFO, LedgerConensus) << "We closed at " << boost::lexical_cast<std::string>(mCloseTime);
uint64 closeTotal = mCloseTime; uint64 closeTotal = mCloseTime;
int closeCount = 1; int closeCount = 1;
for (std::map<uint32, int>::iterator it = mCloseTimes.begin(), end = mCloseTimes.end(); it != end; ++it) for (std::map<uint32, int>::iterator it = mCloseTimes.begin(), end = mCloseTimes.end(); it != end; ++it)
{ // FIXME: Use median, not average { // FIXME: Use median, not average
cLog(lsINFO) << boost::lexical_cast<std::string>(it->second) << " time votes for " WriteLog (lsINFO, LedgerConensus) << boost::lexical_cast<std::string>(it->second) << " time votes for "
<< boost::lexical_cast<std::string>(it->first); << boost::lexical_cast<std::string>(it->first);
closeCount += it->second; closeCount += it->second;
closeTotal += static_cast<uint64>(it->first) * static_cast<uint64>(it->second); closeTotal += static_cast<uint64>(it->first) * static_cast<uint64>(it->second);
@@ -1293,7 +1294,7 @@ void LedgerConsensus::accept(SHAMap::ref set, LoadEvent::pointer)
closeTotal += (closeCount / 2); closeTotal += (closeCount / 2);
closeTotal /= closeCount; closeTotal /= closeCount;
int offset = static_cast<int>(closeTotal) - static_cast<int>(mCloseTime); int offset = static_cast<int>(closeTotal) - static_cast<int>(mCloseTime);
cLog(lsINFO) << "Our close offset is estimated at " << offset << " (" << closeCount << ")"; WriteLog (lsINFO, LedgerConensus) << "Our close offset is estimated at " << offset << " (" << closeCount << ")";
theApp->getOPs().closeTimeOffset(offset); theApp->getOPs().closeTimeOffset(offset);
} }
@@ -1306,12 +1307,12 @@ void LedgerConsensus::endConsensus()
void LedgerConsensus::simulate() void LedgerConsensus::simulate()
{ {
cLog(lsINFO) << "Simulating consensus"; WriteLog (lsINFO, LedgerConensus) << "Simulating consensus";
closeLedger(); closeLedger();
mCurrentMSeconds = 100; mCurrentMSeconds = 100;
beginAccept(true); beginAccept(true);
endConsensus(); endConsensus();
cLog(lsINFO) << "Simulation complete"; WriteLog (lsINFO, LedgerConensus) << "Simulation complete";
} }
Json::Value LedgerConsensus::getJson(bool full) Json::Value LedgerConsensus::getJson(bool full)

78
src/cpp/ripple/LedgerEntrySet.cpp
View File

@@ -7,8 +7,6 @@
#include "Log.h" #include "Log.h"
SETUP_LOG();
DECLARE_INSTANCE(LedgerEntrySetEntry); DECLARE_INSTANCE(LedgerEntrySetEntry);
DECLARE_INSTANCE(LedgerEntrySet) DECLARE_INSTANCE(LedgerEntrySet)
@@ -151,7 +149,7 @@ void LedgerEntrySet::entryCreate(SLE::ref sle)
{ {
case taaDELETE: case taaDELETE:
cLog(lsDEBUG) << "Create after Delete = Modify"; WriteLog (lsDEBUG, LedgerEntrySet) << "Create after Delete = Modify";
it->second.mEntry = sle; it->second.mEntry = sle;
it->second.mAction = taaMODIFY; it->second.mAction = taaMODIFY;
it->second.mSeq = mSeq; it->second.mSeq = mSeq;
@@ -303,7 +301,7 @@ SLE::pointer LedgerEntrySet::getForMod(const uint256& node, Ledger::ref ledger,
{ {
if (it->second.mAction == taaDELETE) if (it->second.mAction == taaDELETE)
{ {
cLog(lsFATAL) << "Trying to thread to deleted node"; WriteLog (lsFATAL, LedgerEntrySet) << "Trying to thread to deleted node";
return SLE::pointer(); return SLE::pointer();
} }
if (it->second.mAction == taaCACHED) if (it->second.mAction == taaCACHED)
@@ -334,12 +332,12 @@ bool LedgerEntrySet::threadTx(const RippleAddress& threadTo, Ledger::ref ledger,
boost::unordered_map<uint256, SLE::pointer>& newMods) boost::unordered_map<uint256, SLE::pointer>& newMods)
{ {
#ifdef META_DEBUG #ifdef META_DEBUG
cLog(lsTRACE) << "Thread to " << threadTo.getAccountID(); WriteLog (lsTRACE, LedgerEntrySet) << "Thread to " << threadTo.getAccountID();
#endif #endif
SLE::pointer sle = getForMod(Ledger::getAccountRootIndex(threadTo.getAccountID()), ledger, newMods); SLE::pointer sle = getForMod(Ledger::getAccountRootIndex(threadTo.getAccountID()), ledger, newMods);
if (!sle) if (!sle)
{ {
cLog(lsFATAL) << "Threading to non-existent account: " << threadTo.humanAccountID(); WriteLog (lsFATAL, LedgerEntrySet) << "Threading to non-existent account: " << threadTo.humanAccountID();
assert(false); assert(false);
return false; return false;
} }
@@ -369,14 +367,14 @@ bool LedgerEntrySet::threadOwners(SLE::ref node, Ledger::ref ledger,
if (node->hasOneOwner()) // thread to owner's account if (node->hasOneOwner()) // thread to owner's account
{ {
#ifdef META_DEBUG #ifdef META_DEBUG
cLog(lsTRACE) << "Thread to single owner"; WriteLog (lsTRACE, LedgerEntrySet) << "Thread to single owner";
#endif #endif
return threadTx(node->getOwner(), ledger, newMods); return threadTx(node->getOwner(), ledger, newMods);
} }
else if (node->hasTwoOwners()) // thread to owner's accounts else if (node->hasTwoOwners()) // thread to owner's accounts
{ {
#ifdef META_DEBUG #ifdef META_DEBUG
cLog(lsTRACE) << "Thread to two owners"; WriteLog (lsTRACE, LedgerEntrySet) << "Thread to two owners";
#endif #endif
return return
threadTx(node->getFirstOwner(), ledger, newMods) && threadTx(node->getFirstOwner(), ledger, newMods) &&
@@ -401,21 +399,21 @@ void LedgerEntrySet::calcRawMeta(Serializer& s, TER result, uint32 index)
{ {
case taaMODIFY: case taaMODIFY:
#ifdef META_DEBUG #ifdef META_DEBUG
cLog(lsTRACE) << "Modified Node " << it.first; WriteLog (lsTRACE, LedgerEntrySet) << "Modified Node " << it.first;
#endif #endif
type = &sfModifiedNode; type = &sfModifiedNode;
break; break;
case taaDELETE: case taaDELETE:
#ifdef META_DEBUG #ifdef META_DEBUG
cLog(lsTRACE) << "Deleted Node " << it.first; WriteLog (lsTRACE, LedgerEntrySet) << "Deleted Node " << it.first;
#endif #endif
type = &sfDeletedNode; type = &sfDeletedNode;
break; break;
case taaCREATE: case taaCREATE:
#ifdef META_DEBUG #ifdef META_DEBUG
cLog(lsTRACE) << "Created Node " << it.first; WriteLog (lsTRACE, LedgerEntrySet) << "Created Node " << it.first;
#endif #endif
type = &sfCreatedNode; type = &sfCreatedNode;
break; break;
@@ -510,7 +508,7 @@ void LedgerEntrySet::calcRawMeta(Serializer& s, TER result, uint32 index)
entryModify(it.second); entryModify(it.second);
mSet.addRaw(s, result, index); mSet.addRaw(s, result, index);
cLog(lsTRACE) << "Metadata:" << mSet.getJson(0); WriteLog (lsTRACE, LedgerEntrySet) << "Metadata:" << mSet.getJson(0);
} }
TER LedgerEntrySet::dirCount(const uint256& uRootIndex, uint32& uCount) TER LedgerEntrySet::dirCount(const uint256& uRootIndex, uint32& uCount)
@@ -531,7 +529,7 @@ TER LedgerEntrySet::dirCount(const uint256& uRootIndex, uint32& uCount)
} }
else if (uNodeDir) else if (uNodeDir)
{ {
cLog(lsWARNING) << "dirCount: no such node"; WriteLog (lsWARNING, LedgerEntrySet) << "dirCount: no such node";
assert(false); assert(false);
@@ -553,7 +551,7 @@ TER LedgerEntrySet::dirAdd(
const uint256& uLedgerIndex, const uint256& uLedgerIndex,
FUNCTION_TYPE<void (SLE::ref)> fDescriber) FUNCTION_TYPE<void (SLE::ref)> fDescriber)
{ {
cLog(lsTRACE) << boost::str(boost::format("dirAdd: uRootIndex=%s uLedgerIndex=%s") WriteLog (lsTRACE, LedgerEntrySet) << boost::str(boost::format("dirAdd: uRootIndex=%s uLedgerIndex=%s")
% uRootIndex.ToString() % uRootIndex.ToString()
% uLedgerIndex.ToString()); % uLedgerIndex.ToString());
@@ -637,10 +635,10 @@ TER LedgerEntrySet::dirAdd(
svIndexes.peekValue().push_back(uLedgerIndex); // Append entry. svIndexes.peekValue().push_back(uLedgerIndex); // Append entry.
sleNode->setFieldV256(sfIndexes, svIndexes); // Save entry. sleNode->setFieldV256(sfIndexes, svIndexes); // Save entry.
cLog(lsTRACE) << "dirAdd: creating: root: " << uRootIndex.ToString(); WriteLog (lsTRACE, LedgerEntrySet) << "dirAdd: creating: root: " << uRootIndex.ToString();
cLog(lsTRACE) << "dirAdd: appending: Entry: " << uLedgerIndex.ToString(); WriteLog (lsTRACE, LedgerEntrySet) << "dirAdd: appending: Entry: " << uLedgerIndex.ToString();
cLog(lsTRACE) << "dirAdd: appending: Node: " << strHex(uNodeDir); WriteLog (lsTRACE, LedgerEntrySet) << "dirAdd: appending: Node: " << strHex(uNodeDir);
// cLog(lsINFO) << "dirAdd: appending: PREV: " << svIndexes.peekValue()[0].ToString(); // WriteLog (lsINFO, LedgerEntrySet) << "dirAdd: appending: PREV: " << svIndexes.peekValue()[0].ToString();
return tesSUCCESS; return tesSUCCESS;
} }
@@ -659,7 +657,7 @@ TER LedgerEntrySet::dirDelete(
if (!sleNode) if (!sleNode)
{ {
cLog(lsWARNING) WriteLog (lsWARNING, LedgerEntrySet)
<< boost::str(boost::format("dirDelete: no such node: uRootIndex=%s uNodeDir=%s uLedgerIndex=%s") << boost::str(boost::format("dirDelete: no such node: uRootIndex=%s uNodeDir=%s uLedgerIndex=%s")
% uRootIndex.ToString() % uRootIndex.ToString()
% strHex(uNodeDir) % strHex(uNodeDir)
@@ -694,7 +692,7 @@ TER LedgerEntrySet::dirDelete(
{ {
assert(false); assert(false);
cLog(lsWARNING) << "dirDelete: no such entry"; WriteLog (lsWARNING, LedgerEntrySet) << "dirDelete: no such entry";
return tefBAD_LEDGER; return tefBAD_LEDGER;
} }
@@ -797,14 +795,14 @@ TER LedgerEntrySet::dirDelete(
if (!slePrevious) if (!slePrevious)
{ {
cLog(lsWARNING) << "dirDelete: previous node is missing"; WriteLog (lsWARNING, LedgerEntrySet) << "dirDelete: previous node is missing";
return tefBAD_LEDGER; return tefBAD_LEDGER;
} }
if (!sleNext) if (!sleNext)
{ {
cLog(lsWARNING) << "dirDelete: next node is missing"; WriteLog (lsWARNING, LedgerEntrySet) << "dirDelete: next node is missing";
return tefBAD_LEDGER; return tefBAD_LEDGER;
} }
@@ -898,7 +896,7 @@ bool LedgerEntrySet::dirNext(
} }
uEntryIndex = vuiIndexes[uDirEntry++]; uEntryIndex = vuiIndexes[uDirEntry++];
cLog(lsTRACE) << boost::str(boost::format("dirNext: uDirEntry=%d uEntryIndex=%s") % uDirEntry % uEntryIndex); WriteLog (lsTRACE, LedgerEntrySet) << boost::str(boost::format("dirNext: uDirEntry=%d uEntryIndex=%s") % uDirEntry % uEntryIndex);
return true; return true;
} }
@@ -1010,7 +1008,7 @@ STAmount LedgerEntrySet::rippleOwed(const uint160& uToAccountID, const uint160&
{ {
saBalance.zero(uCurrencyID, uToAccountID); saBalance.zero(uCurrencyID, uToAccountID);
cLog(lsDEBUG) << "rippleOwed: No credit line between " WriteLog (lsDEBUG, LedgerEntrySet) << "rippleOwed: No credit line between "
<< RippleAddress::createHumanAccountID(uFromAccountID) << RippleAddress::createHumanAccountID(uFromAccountID)
<< " and " << " and "
<< RippleAddress::createHumanAccountID(uToAccountID) << RippleAddress::createHumanAccountID(uToAccountID)
@@ -1060,7 +1058,7 @@ uint32 LedgerEntrySet::rippleTransferRate(const uint160& uIssuerID)
? sleAccount->getFieldU32(sfTransferRate) ? sleAccount->getFieldU32(sfTransferRate)
: QUALITY_ONE; : QUALITY_ONE;
cLog(lsDEBUG) << boost::str(boost::format("rippleTransferRate: uIssuerID=%s account_exists=%d transfer_rate=%f") WriteLog (lsDEBUG, LedgerEntrySet) << boost::str(boost::format("rippleTransferRate: uIssuerID=%s account_exists=%d transfer_rate=%f")
% RippleAddress::createHumanAccountID(uIssuerID) % RippleAddress::createHumanAccountID(uIssuerID)
% !!sleAccount % !!sleAccount
% (uQuality/1000000000.0)); % (uQuality/1000000000.0));
@@ -1107,7 +1105,7 @@ uint32 LedgerEntrySet::rippleQualityIn(const uint160& uToAccountID, const uint16
} }
} }
cLog(lsTRACE) << boost::str(boost::format("rippleQuality: %s uToAccountID=%s uFromAccountID=%s uCurrencyID=%s bLine=%d uQuality=%f") WriteLog (lsTRACE, LedgerEntrySet) << boost::str(boost::format("rippleQuality: %s uToAccountID=%s uFromAccountID=%s uCurrencyID=%s bLine=%d uQuality=%f")
% (sfLow == sfLowQualityIn ? "in" : "out") % (sfLow == sfLowQualityIn ? "in" : "out")
% RippleAddress::createHumanAccountID(uToAccountID) % RippleAddress::createHumanAccountID(uToAccountID)
% RippleAddress::createHumanAccountID(uFromAccountID) % RippleAddress::createHumanAccountID(uFromAccountID)
@@ -1171,7 +1169,7 @@ STAmount LedgerEntrySet::accountHolds(const uint160& uAccountID, const uint160&
saAmount = saBalance-uReserve; saAmount = saBalance-uReserve;
} }
cLog(lsTRACE) << boost::str(boost::format("accountHolds: uAccountID=%s saAmount=%s saBalance=%s uReserve=%d") WriteLog (lsTRACE, LedgerEntrySet) << boost::str(boost::format("accountHolds: uAccountID=%s saAmount=%s saBalance=%s uReserve=%d")
% RippleAddress::createHumanAccountID(uAccountID) % RippleAddress::createHumanAccountID(uAccountID)
% saAmount.getFullText() % saAmount.getFullText()
% saBalance.getFullText() % saBalance.getFullText()
@@ -1181,7 +1179,7 @@ STAmount LedgerEntrySet::accountHolds(const uint160& uAccountID, const uint160&
{ {
saAmount = rippleHolds(uAccountID, uCurrencyID, uIssuerID); saAmount = rippleHolds(uAccountID, uCurrencyID, uIssuerID);
cLog(lsTRACE) << boost::str(boost::format("accountHolds: uAccountID=%s saAmount=%s") WriteLog (lsTRACE, LedgerEntrySet) << boost::str(boost::format("accountHolds: uAccountID=%s saAmount=%s")
% RippleAddress::createHumanAccountID(uAccountID) % RippleAddress::createHumanAccountID(uAccountID)
% saAmount.getFullText()); % saAmount.getFullText());
} }
@@ -1203,7 +1201,7 @@ STAmount LedgerEntrySet::accountFunds(const uint160& uAccountID, const STAmount&
{ {
saFunds = saDefault; saFunds = saDefault;
cLog(lsTRACE) << boost::str(boost::format("accountFunds: uAccountID=%s saDefault=%s SELF-FUNDED") WriteLog (lsTRACE, LedgerEntrySet) << boost::str(boost::format("accountFunds: uAccountID=%s saDefault=%s SELF-FUNDED")
% RippleAddress::createHumanAccountID(uAccountID) % RippleAddress::createHumanAccountID(uAccountID)
% saDefault.getFullText()); % saDefault.getFullText());
} }
@@ -1211,7 +1209,7 @@ STAmount LedgerEntrySet::accountFunds(const uint160& uAccountID, const STAmount&
{ {
saFunds = accountHolds(uAccountID, saDefault.getCurrency(), saDefault.getIssuer()); saFunds = accountHolds(uAccountID, saDefault.getCurrency(), saDefault.getIssuer());
cLog(lsTRACE) << boost::str(boost::format("accountFunds: uAccountID=%s saDefault=%s saFunds=%s") WriteLog (lsTRACE, LedgerEntrySet) << boost::str(boost::format("accountFunds: uAccountID=%s saDefault=%s saFunds=%s")
% RippleAddress::createHumanAccountID(uAccountID) % RippleAddress::createHumanAccountID(uAccountID)
% saDefault.getFullText() % saDefault.getFullText()
% saFunds.getFullText()); % saFunds.getFullText());
@@ -1234,7 +1232,7 @@ STAmount LedgerEntrySet::rippleTransferFee(const uint160& uSenderID, const uint1
STAmount saTransferTotal = STAmount::multiply(saAmount, saTransitRate, saAmount.getCurrency(), saAmount.getIssuer()); STAmount saTransferTotal = STAmount::multiply(saAmount, saTransitRate, saAmount.getCurrency(), saAmount.getIssuer());
STAmount saTransferFee = saTransferTotal-saAmount; STAmount saTransferFee = saTransferTotal-saAmount;
cLog(lsDEBUG) << boost::str(boost::format("rippleTransferFee: saTransferFee=%s") WriteLog (lsDEBUG, LedgerEntrySet) << boost::str(boost::format("rippleTransferFee: saTransferFee=%s")
% saTransferFee.getFullText()); % saTransferFee.getFullText());
return saTransferFee; return saTransferFee;
@@ -1321,16 +1319,16 @@ TER LedgerEntrySet::trustDelete(SLE::ref sleRippleState, const uint160& uLowAcco
uint64 uHighNode = sleRippleState->getFieldU64(sfHighNode); uint64 uHighNode = sleRippleState->getFieldU64(sfHighNode);
TER terResult; TER terResult;
cLog(lsTRACE) << "trustDelete: Deleting ripple line: low"; WriteLog (lsTRACE, LedgerEntrySet) << "trustDelete: Deleting ripple line: low";
terResult = dirDelete(false, uLowNode, Ledger::getOwnerDirIndex(uLowAccountID), sleRippleState->getIndex(), false, !bLowNode); terResult = dirDelete(false, uLowNode, Ledger::getOwnerDirIndex(uLowAccountID), sleRippleState->getIndex(), false, !bLowNode);
if (tesSUCCESS == terResult) if (tesSUCCESS == terResult)
{ {
cLog(lsTRACE) << "trustDelete: Deleting ripple line: high"; WriteLog (lsTRACE, LedgerEntrySet) << "trustDelete: Deleting ripple line: high";
terResult = dirDelete(false, uHighNode, Ledger::getOwnerDirIndex(uHighAccountID), sleRippleState->getIndex(), false, !bHighNode); terResult = dirDelete(false, uHighNode, Ledger::getOwnerDirIndex(uHighAccountID), sleRippleState->getIndex(), false, !bHighNode);
} }
cLog(lsTRACE) << "trustDelete: Deleting ripple line: state"; WriteLog (lsTRACE, LedgerEntrySet) << "trustDelete: Deleting ripple line: state";
entryDelete(sleRippleState); entryDelete(sleRippleState);
return terResult; return terResult;
@@ -1367,7 +1365,7 @@ TER LedgerEntrySet::rippleCredit(const uint160& uSenderID, const uint160& uRecei
saBalance.setIssuer(ACCOUNT_ONE); saBalance.setIssuer(ACCOUNT_ONE);
cLog(lsDEBUG) << boost::str(boost::format("rippleCredit: create line: %s --> %s : %s") WriteLog (lsDEBUG, LedgerEntrySet) << boost::str(boost::format("rippleCredit: create line: %s --> %s : %s")
% RippleAddress::createHumanAccountID(uSenderID) % RippleAddress::createHumanAccountID(uSenderID)
% RippleAddress::createHumanAccountID(uReceiverID) % RippleAddress::createHumanAccountID(uReceiverID)
% saAmount.getFullText()); % saAmount.getFullText());
@@ -1393,7 +1391,7 @@ TER LedgerEntrySet::rippleCredit(const uint160& uSenderID, const uint160& uRecei
saBalance -= saAmount; saBalance -= saAmount;
cLog(lsDEBUG) << boost::str(boost::format("rippleCredit: %s --> %s : before=%s amount=%s after=%s") WriteLog (lsDEBUG, LedgerEntrySet) << boost::str(boost::format("rippleCredit: %s --> %s : before=%s amount=%s after=%s")
% RippleAddress::createHumanAccountID(uSenderID) % RippleAddress::createHumanAccountID(uSenderID)
% RippleAddress::createHumanAccountID(uReceiverID) % RippleAddress::createHumanAccountID(uReceiverID)
% saBefore.getFullText() % saBefore.getFullText()
@@ -1475,7 +1473,7 @@ TER LedgerEntrySet::rippleSend(const uint160& uSenderID, const uint160& uReceive
saActual.setIssuer(uIssuerID); // XXX Make sure this done in + above. saActual.setIssuer(uIssuerID); // XXX Make sure this done in + above.
cLog(lsDEBUG) << boost::str(boost::format("rippleSend> %s -- > %s : deliver=%s fee=%s cost=%s") WriteLog (lsDEBUG, LedgerEntrySet) << boost::str(boost::format("rippleSend> %s -- > %s : deliver=%s fee=%s cost=%s")
% RippleAddress::createHumanAccountID(uSenderID) % RippleAddress::createHumanAccountID(uSenderID)
% RippleAddress::createHumanAccountID(uReceiverID) % RippleAddress::createHumanAccountID(uReceiverID)
% saAmount.getFullText() % saAmount.getFullText()
@@ -1509,7 +1507,7 @@ TER LedgerEntrySet::accountSend(const uint160& uSenderID, const uint160& uReceiv
? entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uReceiverID)) ? entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uReceiverID))
: SLE::pointer(); : SLE::pointer();
cLog(lsDEBUG) << boost::str(boost::format("accountSend> %s (%s) -> %s (%s) : %s") WriteLog (lsDEBUG, LedgerEntrySet) << boost::str(boost::format("accountSend> %s (%s) -> %s (%s) : %s")
% RippleAddress::createHumanAccountID(uSenderID) % RippleAddress::createHumanAccountID(uSenderID)
% (sleSender ? (sleSender->getFieldAmount(sfBalance)).getFullText() : "-") % (sleSender ? (sleSender->getFieldAmount(sfBalance)).getFullText() : "-")
% RippleAddress::createHumanAccountID(uReceiverID) % RippleAddress::createHumanAccountID(uReceiverID)
@@ -1537,7 +1535,7 @@ TER LedgerEntrySet::accountSend(const uint160& uSenderID, const uint160& uReceiv
entryModify(sleReceiver); entryModify(sleReceiver);
} }
cLog(lsDEBUG) << boost::str(boost::format("accountSend< %s (%s) -> %s (%s) : %s") WriteLog (lsDEBUG, LedgerEntrySet) << boost::str(boost::format("accountSend< %s (%s) -> %s (%s) : %s")
% RippleAddress::createHumanAccountID(uSenderID) % RippleAddress::createHumanAccountID(uSenderID)
% (sleSender ? (sleSender->getFieldAmount(sfBalance)).getFullText() : "-") % (sleSender ? (sleSender->getFieldAmount(sfBalance)).getFullText() : "-")
% RippleAddress::createHumanAccountID(uReceiverID) % RippleAddress::createHumanAccountID(uReceiverID)
@@ -1548,7 +1546,7 @@ TER LedgerEntrySet::accountSend(const uint160& uSenderID, const uint160& uReceiv
{ {
STAmount saActual; STAmount saActual;
cLog(lsDEBUG) << boost::str(boost::format("accountSend: %s -> %s : %s") WriteLog (lsDEBUG, LedgerEntrySet) << boost::str(boost::format("accountSend: %s -> %s : %s")
% RippleAddress::createHumanAccountID(uSenderID) % RippleAddress::createHumanAccountID(uSenderID)
% RippleAddress::createHumanAccountID(uReceiverID) % RippleAddress::createHumanAccountID(uReceiverID)
% saAmount.getFullText()); % saAmount.getFullText());

70
src/cpp/ripple/LedgerMaster.cpp
View File

@@ -8,8 +8,6 @@
#include "Log.h" #include "Log.h"
#include "PFRequest.h" #include "PFRequest.h"
SETUP_LOG();
#define MIN_VALIDATION_RATIO 150 // 150/256ths of validations of previous ledger #define MIN_VALIDATION_RATIO 150 // 150/256ths of validations of previous ledger
#define MAX_LEDGER_GAP 100 // Don't catch up more than 100 ledgers (cannot exceed 256) #define MAX_LEDGER_GAP 100 // Don't catch up more than 100 ledgers (cannot exceed 256)
@@ -52,14 +50,14 @@ void LedgerMaster::pushLedger(Ledger::pointer newLedger)
{ {
// Caller should already have properly assembled this ledger into "ready-to-close" form -- // Caller should already have properly assembled this ledger into "ready-to-close" form --
// all candidate transactions must already be applied // all candidate transactions must already be applied
cLog(lsINFO) << "PushLedger: " << newLedger->getHash(); WriteLog (lsINFO, LedgerMaster) << "PushLedger: " << newLedger->getHash();
boost::recursive_mutex::scoped_lock ml(mLock); boost::recursive_mutex::scoped_lock ml(mLock);
if (!mPubLedger) if (!mPubLedger)
mPubLedger = newLedger; mPubLedger = newLedger;
if (!!mFinalizedLedger) if (!!mFinalizedLedger)
{ {
mFinalizedLedger->setClosed(); mFinalizedLedger->setClosed();
cLog(lsTRACE) << "Finalizes: " << mFinalizedLedger->getHash(); WriteLog (lsTRACE, LedgerMaster) << "Finalizes: " << mFinalizedLedger->getHash();
} }
mFinalizedLedger = mCurrentLedger; mFinalizedLedger = mCurrentLedger;
mCurrentLedger = newLedger; mCurrentLedger = newLedger;
@@ -77,7 +75,7 @@ void LedgerMaster::pushLedger(Ledger::pointer newLCL, Ledger::pointer newOL, boo
assert(newLCL->isClosed()); assert(newLCL->isClosed());
assert(newLCL->isImmutable()); assert(newLCL->isImmutable());
mLedgerHistory.addAcceptedLedger(newLCL, fromConsensus); mLedgerHistory.addAcceptedLedger(newLCL, fromConsensus);
cLog(lsINFO) << "StashAccepted: " << newLCL->getHash(); WriteLog (lsINFO, LedgerMaster) << "StashAccepted: " << newLCL->getHash();
} }
{ {
@@ -137,10 +135,10 @@ Ledger::pointer LedgerMaster::closeLedger(bool recover)
} }
catch (...) catch (...)
{ // CHECKME: We got a few of these { // CHECKME: We got a few of these
cLog(lsWARNING) << "Held transaction throws"; WriteLog (lsWARNING, LedgerMaster) << "Held transaction throws";
} }
} }
tLog(recovers != 0, lsINFO) << "Recovered " << recovers << " held transactions"; CondLog (recovers != 0, lsINFO, LedgerMaster) << "Recovered " << recovers << " held transactions";
mHeldTransactions.reset(closingLedger->getHash()); mHeldTransactions.reset(closingLedger->getHash());
} }
@@ -248,7 +246,7 @@ bool LedgerMaster::acquireMissingLedger(Ledger::ref origLedger, const uint256& l
Ledger::pointer ledger = mLedgerHistory.getLedgerBySeq(ledgerSeq); Ledger::pointer ledger = mLedgerHistory.getLedgerBySeq(ledgerSeq);
if (ledger && (Ledger::getHashByIndex(ledgerSeq) == ledgerHash)) if (ledger && (Ledger::getHashByIndex(ledgerSeq) == ledgerHash))
{ {
cLog(lsTRACE) << "Ledger hash found in database"; WriteLog (lsTRACE, LedgerMaster) << "Ledger hash found in database";
theApp->getJobQueue().addJob(jtPUBOLDLEDGER, "LedgerMaster::asyncAccept", theApp->getJobQueue().addJob(jtPUBOLDLEDGER, "LedgerMaster::asyncAccept",
BIND_TYPE(&LedgerMaster::asyncAccept, this, ledger)); BIND_TYPE(&LedgerMaster::asyncAccept, this, ledger));
return true; return true;
@@ -256,7 +254,7 @@ bool LedgerMaster::acquireMissingLedger(Ledger::ref origLedger, const uint256& l
if (theApp->getMasterLedgerAcquire().isFailure(ledgerHash)) if (theApp->getMasterLedgerAcquire().isFailure(ledgerHash))
{ {
cLog(lsTRACE) << "Already failed to acquire " << ledgerSeq; WriteLog (lsTRACE, LedgerMaster) << "Already failed to acquire " << ledgerSeq;
return false; return false;
} }
@@ -289,7 +287,7 @@ bool LedgerMaster::acquireMissingLedger(Ledger::ref origLedger, const uint256& l
{ {
if (timeoutCount > 2) if (timeoutCount > 2)
{ {
cLog(lsDEBUG) << "Not acquiring due to timeouts"; WriteLog (lsDEBUG, LedgerMaster) << "Not acquiring due to timeouts";
} }
else else
{ {
@@ -345,7 +343,7 @@ bool LedgerMaster::acquireMissingLedger(Ledger::ref origLedger, const uint256& l
target->sendPacket(packet, false); target->sendPacket(packet, false);
} }
else else
cLog(lsTRACE) << "No peer for fetch pack"; WriteLog (lsTRACE, LedgerMaster) << "No peer for fetch pack";
} }
} }
@@ -358,7 +356,7 @@ void LedgerMaster::missingAcquireComplete(LedgerAcquire::pointer acq)
if (acq->isFailed() && (mMissingSeq != 0)) if (acq->isFailed() && (mMissingSeq != 0))
{ {
cLog(lsWARNING) << "Acquire failed for " << mMissingSeq; WriteLog (lsWARNING, LedgerMaster) << "Acquire failed for " << mMissingSeq;
} }
mMissingLedger.reset(); mMissingLedger.reset();
@@ -378,7 +376,7 @@ bool LedgerMaster::shouldAcquire(uint32 currentLedger, uint32 ledgerHistory, uin
if (candidateLedger >= currentLedger) if (candidateLedger >= currentLedger)
ret = true; ret = true;
else ret = (currentLedger - candidateLedger) <= ledgerHistory; else ret = (currentLedger - candidateLedger) <= ledgerHistory;
cLog(lsTRACE) << "Missing ledger " << candidateLedger << (ret ? " should" : " should NOT") << " be acquired"; WriteLog (lsTRACE, LedgerMaster) << "Missing ledger " << candidateLedger << (ret ? " should" : " should NOT") << " be acquired";
return ret; return ret;
} }
@@ -394,19 +392,19 @@ void LedgerMaster::resumeAcquiring()
if (mMissingLedger || !theConfig.LEDGER_HISTORY) if (mMissingLedger || !theConfig.LEDGER_HISTORY)
{ {
tLog(mMissingLedger, lsDEBUG) << "Fetch already in progress, not resuming"; CondLog (mMissingLedger, lsDEBUG, LedgerMaster) << "Fetch already in progress, not resuming";
return; return;
} }
uint32 prevMissing = mCompleteLedgers.prevMissing(mFinalizedLedger->getLedgerSeq()); uint32 prevMissing = mCompleteLedgers.prevMissing(mFinalizedLedger->getLedgerSeq());
if (prevMissing == RangeSet::RangeSetAbsent) if (prevMissing == RangeSet::RangeSetAbsent)
{ {
cLog(lsDEBUG) << "no prior missing ledger, not resuming"; WriteLog (lsDEBUG, LedgerMaster) << "no prior missing ledger, not resuming";
return; return;
} }
if (shouldAcquire(mCurrentLedger->getLedgerSeq(), theConfig.LEDGER_HISTORY, prevMissing)) if (shouldAcquire(mCurrentLedger->getLedgerSeq(), theConfig.LEDGER_HISTORY, prevMissing))
{ {
cLog(lsTRACE) << "Resuming at " << prevMissing; WriteLog (lsTRACE, LedgerMaster) << "Resuming at " << prevMissing;
assert(!mCompleteLedgers.hasValue(prevMissing)); assert(!mCompleteLedgers.hasValue(prevMissing));
Ledger::pointer nextLedger = getLedgerBySeq(prevMissing + 1); Ledger::pointer nextLedger = getLedgerBySeq(prevMissing + 1);
if (nextLedger) if (nextLedger)
@@ -414,7 +412,7 @@ void LedgerMaster::resumeAcquiring()
else else
{ {
mCompleteLedgers.clearValue(prevMissing); mCompleteLedgers.clearValue(prevMissing);
cLog(lsINFO) << "We have a gap at: " << prevMissing + 1; WriteLog (lsINFO, LedgerMaster) << "We have a gap at: " << prevMissing + 1;
} }
} }
} }
@@ -435,7 +433,7 @@ void LedgerMaster::fixMismatch(Ledger::ref ledger)
Ledger::pointer otherLedger = getLedgerBySeq(lSeq); Ledger::pointer otherLedger = getLedgerBySeq(lSeq);
if (otherLedger && (otherLedger->getHash() == hash)) if (otherLedger && (otherLedger->getHash() == hash))
{ // we closed the seam { // we closed the seam
tLog(invalidate != 0, lsWARNING) << "Match at " << lSeq << ", " << CondLog (invalidate != 0, lsWARNING, LedgerMaster) << "Match at " << lSeq << ", " <<
invalidate << " prior ledgers invalidated"; invalidate << " prior ledgers invalidated";
return; return;
} }
@@ -445,12 +443,12 @@ void LedgerMaster::fixMismatch(Ledger::ref ledger)
} }
// all prior ledgers invalidated // all prior ledgers invalidated
tLog(invalidate != 0, lsWARNING) << "All " << invalidate << " prior ledgers invalidated"; CondLog (invalidate != 0, lsWARNING, LedgerMaster) << "All " << invalidate << " prior ledgers invalidated";
} }
void LedgerMaster::setFullLedger(Ledger::pointer ledger) void LedgerMaster::setFullLedger(Ledger::pointer ledger)
{ // A new ledger has been accepted as part of the trusted chain { // A new ledger has been accepted as part of the trusted chain
cLog(lsDEBUG) << "Ledger " << ledger->getLedgerSeq() << " accepted :" << ledger->getHash(); WriteLog (lsDEBUG, LedgerMaster) << "Ledger " << ledger->getLedgerSeq() << " accepted :" << ledger->getHash();
assert(ledger->peekAccountStateMap()->getHash().isNonZero()); assert(ledger->peekAccountStateMap()->getHash().isNonZero());
if (theApp->getOPs().isNeedNetworkLedger()) if (theApp->getOPs().isNeedNetworkLedger())
@@ -471,7 +469,7 @@ void LedgerMaster::setFullLedger(Ledger::pointer ledger)
Ledger::pointer prevLedger = getLedgerBySeq(ledger->getLedgerSeq() - 1); Ledger::pointer prevLedger = getLedgerBySeq(ledger->getLedgerSeq() - 1);
if (!prevLedger || (prevLedger->getHash() != ledger->getParentHash())) if (!prevLedger || (prevLedger->getHash() != ledger->getParentHash()))
{ {
cLog(lsWARNING) << "Acquired ledger invalidates previous ledger: " << WriteLog (lsWARNING, LedgerMaster) << "Acquired ledger invalidates previous ledger: " <<
(prevLedger ? "hashMismatch" : "missingLedger"); (prevLedger ? "hashMismatch" : "missingLedger");
fixMismatch(ledger); fixMismatch(ledger);
} }
@@ -486,13 +484,13 @@ void LedgerMaster::setFullLedger(Ledger::pointer ledger)
if (mMissingLedger || !theConfig.LEDGER_HISTORY) if (mMissingLedger || !theConfig.LEDGER_HISTORY)
{ {
tLog(mMissingLedger, lsDEBUG) << "Fetch already in progress, " << mMissingLedger->getTimeouts() << " timeouts"; CondLog (mMissingLedger, lsDEBUG, LedgerMaster) << "Fetch already in progress, " << mMissingLedger->getTimeouts() << " timeouts";
return; return;
} }
if (theApp->getJobQueue().getJobCountTotal(jtPUBOLDLEDGER) > 1) if (theApp->getJobQueue().getJobCountTotal(jtPUBOLDLEDGER) > 1)
{ {
cLog(lsDEBUG) << "Too many pending ledger saves"; WriteLog (lsDEBUG, LedgerMaster) << "Too many pending ledger saves";
return; return;
} }
@@ -501,10 +499,10 @@ void LedgerMaster::setFullLedger(Ledger::pointer ledger)
{ {
if (!shouldAcquire(mCurrentLedger->getLedgerSeq(), theConfig.LEDGER_HISTORY, ledger->getLedgerSeq() - 1)) if (!shouldAcquire(mCurrentLedger->getLedgerSeq(), theConfig.LEDGER_HISTORY, ledger->getLedgerSeq() - 1))
{ {
cLog(lsTRACE) << "Don't need any ledgers"; WriteLog (lsTRACE, LedgerMaster) << "Don't need any ledgers";
return; return;
} }
cLog(lsDEBUG) << "We need the ledger before the ledger we just accepted: " << ledger->getLedgerSeq() - 1; WriteLog (lsDEBUG, LedgerMaster) << "We need the ledger before the ledger we just accepted: " << ledger->getLedgerSeq() - 1;
acquireMissingLedger(ledger, ledger->getParentHash(), ledger->getLedgerSeq() - 1); acquireMissingLedger(ledger, ledger->getParentHash(), ledger->getLedgerSeq() - 1);
} }
else else
@@ -512,12 +510,12 @@ void LedgerMaster::setFullLedger(Ledger::pointer ledger)
uint32 prevMissing = mCompleteLedgers.prevMissing(ledger->getLedgerSeq()); uint32 prevMissing = mCompleteLedgers.prevMissing(ledger->getLedgerSeq());
if (prevMissing == RangeSet::RangeSetAbsent) if (prevMissing == RangeSet::RangeSetAbsent)
{ {
cLog(lsDEBUG) << "no prior missing ledger"; WriteLog (lsDEBUG, LedgerMaster) << "no prior missing ledger";
return; return;
} }
if (shouldAcquire(mCurrentLedger->getLedgerSeq(), theConfig.LEDGER_HISTORY, prevMissing)) if (shouldAcquire(mCurrentLedger->getLedgerSeq(), theConfig.LEDGER_HISTORY, prevMissing))
{ {
cLog(lsDEBUG) << "Ledger " << prevMissing << " is needed"; WriteLog (lsDEBUG, LedgerMaster) << "Ledger " << prevMissing << " is needed";
assert(!mCompleteLedgers.hasValue(prevMissing)); assert(!mCompleteLedgers.hasValue(prevMissing));
Ledger::pointer nextLedger = getLedgerBySeq(prevMissing + 1); Ledger::pointer nextLedger = getLedgerBySeq(prevMissing + 1);
if (nextLedger) if (nextLedger)
@@ -525,11 +523,11 @@ void LedgerMaster::setFullLedger(Ledger::pointer ledger)
else else
{ {
mCompleteLedgers.clearValue(prevMissing); mCompleteLedgers.clearValue(prevMissing);
cLog(lsWARNING) << "We have a gap we can't fix: " << prevMissing + 1; WriteLog (lsWARNING, LedgerMaster) << "We have a gap we can't fix: " << prevMissing + 1;
} }
} }
else else
cLog(lsTRACE) << "Shouldn't acquire"; WriteLog (lsTRACE, LedgerMaster) << "Shouldn't acquire";
} }
} }
@@ -566,7 +564,7 @@ void LedgerMaster::checkAccept(const uint256& hash, uint32 seq)
if (theApp->getValidations().getTrustedValidationCount(hash) < minVal) // nothing we can do if (theApp->getValidations().getTrustedValidationCount(hash) < minVal) // nothing we can do
return; return;
cLog(lsINFO) << "Advancing accepted ledger to " << seq << " with >= " << minVal << " validations"; WriteLog (lsINFO, LedgerMaster) << "Advancing accepted ledger to " << seq << " with >= " << minVal << " validations";
mLastValidateHash = hash; mLastValidateHash = hash;
mLastValidateSeq = seq; mLastValidateSeq = seq;
@@ -594,7 +592,7 @@ void LedgerMaster::tryPublish()
} }
else if (mValidLedger->getLedgerSeq() > (mPubLedger->getLedgerSeq() + MAX_LEDGER_GAP)) else if (mValidLedger->getLedgerSeq() > (mPubLedger->getLedgerSeq() + MAX_LEDGER_GAP))
{ {
cLog(lsWARNING) << "Gap in validated ledger stream " << mPubLedger->getLedgerSeq() << " - " << WriteLog (lsWARNING, LedgerMaster) << "Gap in validated ledger stream " << mPubLedger->getLedgerSeq() << " - " <<
mValidLedger->getLedgerSeq() - 1; mValidLedger->getLedgerSeq() - 1;
mPubLedger = mValidLedger; mPubLedger = mValidLedger;
mPubLedgers.push_back(mValidLedger); mPubLedgers.push_back(mValidLedger);
@@ -603,7 +601,7 @@ void LedgerMaster::tryPublish()
{ {
for (uint32 seq = mPubLedger->getLedgerSeq() + 1; seq <= mValidLedger->getLedgerSeq(); ++seq) for (uint32 seq = mPubLedger->getLedgerSeq() + 1; seq <= mValidLedger->getLedgerSeq(); ++seq)
{ {
cLog(lsTRACE) << "Trying to publish ledger " << seq; WriteLog (lsTRACE, LedgerMaster) << "Trying to publish ledger " << seq;
Ledger::pointer ledger; Ledger::pointer ledger;
uint256 hash; uint256 hash;
@@ -618,7 +616,7 @@ void LedgerMaster::tryPublish()
hash = mValidLedger->getLedgerHash(seq); hash = mValidLedger->getLedgerHash(seq);
if (hash.isZero()) if (hash.isZero())
{ {
cLog(lsFATAL) << "Ledger: " << mValidLedger->getLedgerSeq() << " does not have hash for " << WriteLog (lsFATAL, LedgerMaster) << "Ledger: " << mValidLedger->getLedgerSeq() << " does not have hash for " <<
seq; seq;
assert(false); assert(false);
} }
@@ -634,7 +632,7 @@ void LedgerMaster::tryPublish()
{ {
if (theApp->getMasterLedgerAcquire().isFailure(hash)) if (theApp->getMasterLedgerAcquire().isFailure(hash))
{ {
cLog(lsWARNING) << "Unable to acquire a recent validated ledger"; WriteLog (lsWARNING, LedgerMaster) << "Unable to acquire a recent validated ledger";
} }
else else
{ {
@@ -650,7 +648,7 @@ void LedgerMaster::tryPublish()
mPubLedgers.push_back(mPubLedger); mPubLedgers.push_back(mPubLedger);
} }
else else
cLog(lsWARNING) << "Failed to acquire a published ledger"; WriteLog (lsWARNING, LedgerMaster) << "Failed to acquire a published ledger";
} }
} }
} }
@@ -699,7 +697,7 @@ void LedgerMaster::pubThread()
BOOST_FOREACH(Ledger::ref l, ledgers) BOOST_FOREACH(Ledger::ref l, ledgers)
{ {
cLog(lsDEBUG) << "Publishing ledger " << l->getLedgerSeq(); WriteLog (lsDEBUG, LedgerMaster) << "Publishing ledger " << l->getLedgerSeq();
setFullLedger(l); // OPTIMIZEME: This is actually more work than we need to do setFullLedger(l); // OPTIMIZEME: This is actually more work than we need to do
theApp->getOPs().pubLedger(l); theApp->getOPs().pubLedger(l);
published = true; published = true;

24
src/cpp/ripple/LedgerTiming.cpp
View File

@@ -6,7 +6,9 @@
#include <boost/format.hpp> #include <boost/format.hpp>
#include "Log.h" #include "Log.h"
SETUP_LOG();
// VFALCO: Should rename ContinuousLedgerTiming to LedgerTiming
struct LedgerTiming;
// NOTE: First and last times must be repeated // NOTE: First and last times must be repeated
int ContinuousLedgerTiming::LedgerTimeResolution[] = { 10, 10, 20, 30, 60, 90, 120, 120 }; int ContinuousLedgerTiming::LedgerTimeResolution[] = { 10, 10, 20, 30, 60, 90, 120, 120 };
@@ -26,7 +28,7 @@ bool ContinuousLedgerTiming::shouldClose(
if ((previousMSeconds < -1000) || (previousMSeconds > 600000) || if ((previousMSeconds < -1000) || (previousMSeconds > 600000) ||
(currentMSeconds < -1000) || (currentMSeconds > 600000)) (currentMSeconds < -1000) || (currentMSeconds > 600000))
{ {
cLog(lsWARNING) << WriteLog (lsWARNING, LedgerTiming) <<
boost::str(boost::format("CLC::shouldClose range Trans=%s, Prop: %d/%d, Secs: %d (last:%d)") boost::str(boost::format("CLC::shouldClose range Trans=%s, Prop: %d/%d, Secs: %d (last:%d)")
% (anyTransactions ? "yes" : "no") % previousProposers % proposersClosed % (anyTransactions ? "yes" : "no") % previousProposers % proposersClosed
% currentMSeconds % previousMSeconds); % currentMSeconds % previousMSeconds);
@@ -37,14 +39,14 @@ bool ContinuousLedgerTiming::shouldClose(
{ // no transactions so far this interval { // no transactions so far this interval
if (proposersClosed > (previousProposers / 4)) // did we miss a transaction? if (proposersClosed > (previousProposers / 4)) // did we miss a transaction?
{ {
cLog(lsTRACE) << "no transactions, many proposers: now (" << proposersClosed << " closed, " WriteLog (lsTRACE, LedgerTiming) << "no transactions, many proposers: now (" << proposersClosed << " closed, "
<< previousProposers << " before)"; << previousProposers << " before)";
return true; return true;
} }
#if 0 // This false triggers on the genesis ledger #if 0 // This false triggers on the genesis ledger
if (previousMSeconds > (1000 * (LEDGER_IDLE_INTERVAL + 2))) // the last ledger was very slow to close if (previousMSeconds > (1000 * (LEDGER_IDLE_INTERVAL + 2))) // the last ledger was very slow to close
{ {
cLog(lsTRACE) << "was slow to converge (p=" << (previousMSeconds) << ")"; WriteLog (lsTRACE, LedgerTiming) << "was slow to converge (p=" << (previousMSeconds) << ")";
if (previousMSeconds < 2000) if (previousMSeconds < 2000)
return previousMSeconds; return previousMSeconds;
return previousMSeconds - 1000; return previousMSeconds - 1000;
@@ -55,13 +57,13 @@ bool ContinuousLedgerTiming::shouldClose(
if ((openMSeconds < LEDGER_MIN_CLOSE) && ((proposersClosed + proposersValidated) < (previousProposers / 2 ))) if ((openMSeconds < LEDGER_MIN_CLOSE) && ((proposersClosed + proposersValidated) < (previousProposers / 2 )))
{ {
cLog(lsDEBUG) << "Must wait minimum time before closing"; WriteLog (lsDEBUG, LedgerTiming) << "Must wait minimum time before closing";
return false; return false;
} }
if ((currentMSeconds < previousMSeconds) && ((proposersClosed + proposersValidated) < previousProposers)) if ((currentMSeconds < previousMSeconds) && ((proposersClosed + proposersValidated) < previousProposers))
{ {
cLog(lsDEBUG) << "We are waiting for more closes/validations"; WriteLog (lsDEBUG, LedgerTiming) << "We are waiting for more closes/validations";
return false; return false;
} }
@@ -80,7 +82,7 @@ bool ContinuousLedgerTiming::haveConsensus(
bool forReal, // deciding whether to stop consensus process bool forReal, // deciding whether to stop consensus process
bool& failed) // we can't reach a consensus bool& failed) // we can't reach a consensus
{ {
cLog(lsTRACE) << boost::str(boost::format("CLC::haveConsensus: prop=%d/%d agree=%d validated=%d time=%d/%d%s") % WriteLog (lsTRACE, LedgerTiming) << boost::str(boost::format("CLC::haveConsensus: prop=%d/%d agree=%d validated=%d time=%d/%d%s") %
currentProposers % previousProposers % currentAgree % currentFinished % currentAgreeTime % previousAgreeTime % currentProposers % previousProposers % currentAgree % currentFinished % currentAgreeTime % previousAgreeTime %
(forReal ? "" : "X")); (forReal ? "" : "X"));
@@ -91,7 +93,7 @@ bool ContinuousLedgerTiming::haveConsensus(
{ // Less than 3/4 of the last ledger's proposers are present, we may need more time { // Less than 3/4 of the last ledger's proposers are present, we may need more time
if (currentAgreeTime < (previousAgreeTime + LEDGER_MIN_CONSENSUS)) if (currentAgreeTime < (previousAgreeTime + LEDGER_MIN_CONSENSUS))
{ {
tLog(forReal, lsTRACE) << "too fast, not enough proposers"; CondLog (forReal, lsTRACE, LedgerTiming) << "too fast, not enough proposers";
return false; return false;
} }
} }
@@ -99,7 +101,7 @@ bool ContinuousLedgerTiming::haveConsensus(
// If 80% of current proposers (plus us) agree on a set, we have consensus // If 80% of current proposers (plus us) agree on a set, we have consensus
if (((currentAgree * 100 + 100) / (currentProposers + 1)) > 80) if (((currentAgree * 100 + 100) / (currentProposers + 1)) > 80)
{ {
tLog(forReal, lsINFO) << "normal consensus"; CondLog (forReal, lsINFO, LedgerTiming) << "normal consensus";
failed = false; failed = false;
return true; return true;
} }
@@ -107,13 +109,13 @@ bool ContinuousLedgerTiming::haveConsensus(
// If 80% of the nodes on your UNL have moved on, you should declare consensus // If 80% of the nodes on your UNL have moved on, you should declare consensus
if (((currentFinished * 100) / (currentProposers + 1)) > 80) if (((currentFinished * 100) / (currentProposers + 1)) > 80)
{ {
tLog(forReal, lsWARNING) << "We see no consensus, but 80% of nodes have moved on"; CondLog (forReal, lsWARNING, LedgerTiming) << "We see no consensus, but 80% of nodes have moved on";
failed = true; failed = true;
return true; return true;
} }
// no consensus yet // no consensus yet
tLog(forReal, lsTRACE) << "no consensus"; CondLog (forReal, lsTRACE, LedgerTiming) << "no consensus";
return false; return false;
} }

8
src/cpp/ripple/Log.h
View File

@@ -19,16 +19,20 @@ namespace boost {
#include "types.h" #include "types.h"
// DEPRECATED
// Put at the beginning of a C++ file that needs its own log partition // Put at the beginning of a C++ file that needs its own log partition
#define SETUP_LOG() static LogPartition logPartition(__FILE__) #define SETUP_LOG() static LogPartition logPartition(__FILE__)
#define SETUP_NLOG(x) static LogPartition logPartition(x) #define SETUP_NLOG(x) static LogPartition logPartition(x)
// DEPRECATED
// Standard conditional log // Standard conditional log
#define cLog(x) if (!logPartition.doLog(x)) do {} while (0); else Log(x, logPartition) #define cLog(x) if (!logPartition.doLog(x)) do {} while (0); else Log(x, logPartition)
// DEPRECATED
// Log only if an additional condition 'c' is true. Condition is not computed if not needed // Log only if an additional condition 'c' is true. Condition is not computed if not needed
#define tLog(c,x) if (!logPartition.doLog(x) || !(c)) do {} while(0); else Log(x, logPartition) #define tLog(c,x) if (!logPartition.doLog(x) || !(c)) do {} while(0); else Log(x, logPartition)
// DEPRECATED
// Check if should log // Check if should log
#define sLog(x) (logPartition.doLog(x)) #define sLog(x) (logPartition.doLog(x))
@@ -125,7 +129,9 @@ inline Log getLog (LogSeverity level)
return Log (level, getLogPartition <Key> ()); return Log (level, getLogPartition <Key> ());
} }
#define WriteLog(s, k) if (!getLogPartition <k> ().doLog (s)) do {} while (0); else Log (s, getLogPartition <k> ()) #define ShouldLog(s, k) (getLogPartition <k> ().doLog (s))
#define WriteLog(s, k) if (!ShouldLog (s, k)) do {} while (0); else Log (s, getLogPartition <k> ())
#define CondLog(c, s, k) if (!ShouldLog (s, k) || !(c)) do {} while(0); else Log(s, getLogPartition <k> ())
#endif #endif

8
src/cpp/ripple/OrderBookDB.cpp
View File

@@ -6,8 +6,6 @@
#include "Application.h" #include "Application.h"
#include "Log.h" #include "Log.h"
SETUP_LOG();
OrderBookDB::OrderBookDB() : mSeq(0) OrderBookDB::OrderBookDB() : mSeq(0)
{ {
@@ -34,7 +32,7 @@ void OrderBookDB::setup(Ledger::ref ledger)
mDestMap.clear(); mDestMap.clear();
mSourceMap.clear(); mSourceMap.clear();
cLog(lsDEBUG) << "OrderBookDB>"; WriteLog (lsDEBUG, OrderBookDB) << "OrderBookDB>";
// walk through the entire ledger looking for orderbook entries // walk through the entire ledger looking for orderbook entries
uint256 currentIndex = ledger->getFirstLedgerIndex(); uint256 currentIndex = ledger->getFirstLedgerIndex();
@@ -63,7 +61,7 @@ void OrderBookDB::setup(Ledger::ref ledger)
currentIndex = ledger->getNextLedgerIndex(currentIndex); currentIndex = ledger->getNextLedgerIndex(currentIndex);
} }
cLog(lsDEBUG) << "OrderBookDB<"; WriteLog (lsDEBUG, OrderBookDB) << "OrderBookDB<";
} }
// return list of all orderbooks that want this issuerID and currencyID // return list of all orderbooks that want this issuerID and currencyID
@@ -186,7 +184,7 @@ void OrderBookDB::processTxn(Ledger::ref ledger, const ALTransaction& alTx, Json
} }
catch (...) catch (...)
{ {
cLog(lsINFO) << "Fields not found in OrderBookDB::processTxn"; WriteLog (lsINFO, OrderBookDB) << "Fields not found in OrderBookDB::processTxn";
} }
} }
} }

300
src/cpp/ripple/RippleCalc.cpp
View File

File diff suppressed because it is too large Load Diff