ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-22 20:15:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor SuppressionTable into IHashRouter

Browse Source 
Conflicts:
	src/cpp/ripple/Application.h
This commit is contained in:
Vinnie Falco
2013-06-02 22:40:36 -07:00
parent fb487bdb41
commit 594c47f16b
14 changed files with 284 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
modules/ripple_main/ripple_main.cpp
View File

@@ -28,11 +28,15 @@
#include <cassert>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <openssl/ec.h>
#include <openssl/ripemd.h>
#include <openssl/sha.h>
#include <string>
#include <vector>
#include <boost/algorithm/string.hpp>
#include <boost/bind.hpp>
@@ -46,8 +50,10 @@
#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
//------------------------------------------------------------------------------
@@ -128,6 +134,7 @@
// New abstract interfaces
#include "src/cpp/ripple/ripple_IFeatures.h"
#include "src/cpp/ripple/ripple_IFeeVote.h"
#include "src/cpp/ripple/ripple_IHashRouter.h"
#include "src/cpp/ripple/ripple_ILoadFeeTrack.h"
#include "src/cpp/ripple/ripple_IValidations.h"
#include "src/cpp/ripple/ripple_IUniqueNodeList.h"
@@ -238,7 +245,6 @@ static DH* handleTmpDh(SSL* ssl, int is_export, int iKeyLength)
#include "src/cpp/ripple/ripple_HashValue.cpp"
// sockets
#include "src/cpp/ripple/Suppression.cpp" // no log
#include "src/cpp/ripple/SNTPClient.cpp"
#include "src/cpp/ripple/ConnectionPool.cpp"
#include "src/cpp/ripple/NetworkOPs.cpp"
@@ -265,6 +271,7 @@ static DH* handleTmpDh(SSL* ssl, int is_export, int iKeyLength)
// Implementation of interfaces
#include "src/cpp/ripple/ripple_FeeVote.cpp"
#include "src/cpp/ripple/ripple_HashRouter.cpp"
#include "src/cpp/ripple/ripple_LoadFeeTrack.cpp"
#include "src/cpp/ripple/ripple_Validations.cpp"
#include "src/cpp/ripple/ripple_UniqueNodeList.cpp"

4
newcoin.vcxproj
View File

@@ -1106,7 +1106,7 @@
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="src\cpp\ripple\Suppression.cpp">
<ClCompile Include="src\cpp\ripple\ripple_HashRouter.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
@@ -1674,7 +1674,7 @@
<ClInclude Include="src\cpp\ripple\SHAMap.h" />
<ClInclude Include="src\cpp\ripple\SHAMapSync.h" />
<ClInclude Include="src\cpp\ripple\SNTPClient.h" />
<ClInclude Include="src\cpp\ripple\Suppression.h" />
<ClInclude Include="src\cpp\ripple\ripple_IHashRouter.h" />
<ClInclude Include="src\cpp\ripple\Transaction.h" />
<ClInclude Include="src\cpp\ripple\TransactionEngine.h" />
<ClInclude Include="src\cpp\ripple\TransactionErr.h" />

12
newcoin.vcxproj.filters
View File

@@ -786,9 +786,6 @@
<ClCompile Include="src\cpp\ripple\SNTPClient.cpp">
<Filter>1. Modules\ripple_main\sockets</Filter>
</ClCompile>
<ClCompile Include="src\cpp\ripple\Suppression.cpp">
<Filter>1. Modules\ripple_main\sockets</Filter>
</ClCompile>
<ClCompile Include="src\cpp\ripple\WSDoor.cpp">
<Filter>1. Modules\ripple_main\sockets</Filter>
</ClCompile>
@@ -801,6 +798,9 @@
<ClCompile Include="src\cpp\ripple\ripple_UniqueNodeList.cpp">
<Filter>1. Modules\ripple_main\sockets</Filter>
</ClCompile>
<ClCompile Include="src\cpp\ripple\ripple_HashRouter.cpp">
<Filter>1. Modules\ripple_main\sockets</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="database\sqlite3ext.h">
@@ -1478,15 +1478,15 @@
<ClInclude Include="src\cpp\ripple\SNTPClient.h">
<Filter>1. Modules\ripple_main\sockets</Filter>
</ClInclude>
<ClInclude Include="src\cpp\ripple\Suppression.h">
<Filter>1. Modules\ripple_main\sockets</Filter>
</ClInclude>
<ClInclude Include="src\cpp\ripple\WSConnection.h">
<Filter>1. Modules\ripple_main\sockets</Filter>
</ClInclude>
<ClInclude Include="src\cpp\ripple\ripple_IUniqueNodeList.h">
<Filter>1. Modules\ripple_main\sockets</Filter>
</ClInclude>
<ClInclude Include="src\cpp\ripple\ripple_IHashRouter.h">
<Filter>1. Modules\ripple_main\sockets</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="SConstruct" />

22
src/cpp/ripple/Application.cpp
View File

@@ -36,6 +36,7 @@ Application::Application ()
// VFALCO: New stuff
, mFeeVote (IFeeVote::New (10, 50 * SYSTEM_CURRENCY_PARTS, 12.5 * SYSTEM_CURRENCY_PARTS))
, mFeeTrack (ILoadFeeTrack::New ())
, mHashRouter (IHashRouter::New (IHashRouter::getDefaultHoldTime ()))
, mValidations (IValidations::New ())
, mUNL (IUniqueNodeList::New (mIOService))
// VFALCO: End new stuff
@@ -105,6 +106,7 @@ void sigIntHandler(int)
}
#endif
// VFALCO: TODO, Figure this out it looks like the wrong tool
static void runAux(boost::asio::io_service& svc)
{
setCallingThreadName("aux");
@@ -117,6 +119,26 @@ static void runIO(boost::asio::io_service& io)
io.run();
}
bool Application::isNew(const uint256& s)
{
return mHashRouter->addSuppression(s);
}
bool Application::isNew(const uint256& s, uint64 p)
{
return mHashRouter->addSuppressionPeer(s, p);
}
bool Application::isNew(const uint256& s, uint64 p, int& f)
{
return mHashRouter->addSuppressionPeer(s, p, f);
}
bool Application::isNewFlag(const uint256& s, int f)
{
return mHashRouter->setFlag(s, f);
}
void Application::setup()
{
mJobQueue.setThreadCount();

19
src/cpp/ripple/Application.h
View File

@@ -16,7 +16,6 @@
#include "Peer.h"
#include "NetworkOPs.h"
#include "WSDoor.h"
#include "Suppression.h"
#include "SNTPClient.h"
#include "JobQueue.h"
#include "RPCHandler.h"
@@ -30,6 +29,7 @@
// VFALCO: TODO, Fix forward declares required for header dependency loops
class IFeatureTable;
class IFeeVote;
class IHashRouter;
class ILoadFeeTrack;
class IValidations;
class IUniqueNodeList;
@@ -52,7 +52,6 @@ class Application
TransactionMaster mMasterTransaction;
NetworkOPs mNetOps;
NodeCache mTempNodeCache;
SuppressionTable mSuppressions;
HashedObjectStore mHashedObjectStore;
SLECache mSLECache;
SNTPClient mSNTPClient;
@@ -65,6 +64,7 @@ class Application
// VFALCO: Clean stuff
beast::ScopedPointer <IFeeVote> mFeeVote;
beast::ScopedPointer <ILoadFeeTrack> mFeeTrack;
beast::ScopedPointer <IHashRouter> mHashRouter;
beast::ScopedPointer <IValidations> mValidations;
beast::ScopedPointer <IUniqueNodeList> mUNL;
// VFALCO: End Clean stuff
@@ -116,7 +116,7 @@ public:
NodeCache& getTempNodeCache() { return mTempNodeCache; }
HashedObjectStore& getHashedObjectStore() { return mHashedObjectStore; }
JobQueue& getJobQueue() { return mJobQueue; }
SuppressionTable& getSuppression() { return mSuppressions; }
IHashRouter& getHashRouter() { return *mHashRouter; }
boost::recursive_mutex& getMasterLock() { return mMasterLock; }
ProofOfWorkGenerator& getPowGen() { return mPOWGen; }
LoadManager& getLoadManager() { return mLoadMgr; }
@@ -130,11 +130,14 @@ public:
ILoadFeeTrack& getFeeTrack() { return *mFeeTrack; }
IValidations& getValidations() { return *mValidations; }
bool isNew(const uint256& s) { return mSuppressions.addSuppression(s); }
bool isNew(const uint256& s, uint64 p) { return mSuppressions.addSuppressionPeer(s, p); }
bool isNew(const uint256& s, uint64 p, int& f) { return mSuppressions.addSuppressionPeer(s, p, f); }
bool isNewFlag(const uint256& s, int f) { return mSuppressions.setFlag(s, f); }
bool running() { return mTxnDB != NULL; }
// VFALCO: TODO, eliminate these, change callers to just call IHashRouter directly!
bool isNew(const uint256& s);
bool isNew(const uint256& s, uint64 p);
bool isNew(const uint256& s, uint64 p, int& f);
bool isNewFlag(const uint256& s, int f);
// VFALCO: TODO, Move these to the .cpp
bool running() { return mTxnDB != NULL; } // VFALCO: TODO, replace with nullptr when beast is available
bool getSystemTimeOffset(int& offset) { return mSNTPClient.getOffset(offset); }
DatabaseCon* getRpcDB() { return mRpcDB; }

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

@@ -1004,7 +1004,7 @@ void LedgerConsensus::playbackProposals()
}
#if 0 // FIXME: We can't do delayed relay because we don't have the signature
std::set<uint64> peers
if (relay && theApp->getSuppression().swapSet(proposal.getSuppress(), set, SF_RELAYED))
if (relay && theApp->getHashRouter().swapSet(proposal.getSuppress(), set, SF_RELAYED))
{
WriteLog (lsDEBUG, LedgerConsensus) << "Stored proposal delayed relay";
ripple::TMProposeSet set;

2
src/cpp/ripple/LedgerProposal.h
View File

@@ -48,7 +48,7 @@ public:
const uint160& getPeerID() const { return mPeerID; }
const uint256& getCurrentHash() const { return mCurrentHash; }
const uint256& getPrevLedger() const { return mPreviousLedger; }
const uint256& getSuppression() const { return mSuppression; }
const uint256& getHashRouter() const { return mSuppression; }
uint32 getProposeSeq() const { return mProposeSeq; }
uint32 getCloseTime() const { return mCloseTime; }
const RippleAddress& peekPublic() const { return mPublicKey; }

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

@@ -292,7 +292,7 @@ void NetworkOPs::runTransactionQueue()
if (didApply || (mMode != omFULL))
{
std::set<uint64> peers;
if (theApp->getSuppression().swapSet(txn->getID(), peers, SF_RELAYED))
if (theApp->getHashRouter().swapSet(txn->getID(), peers, SF_RELAYED))
{
ripple::TMTransaction tx;
Serializer s;
@@ -318,7 +318,7 @@ Transaction::pointer NetworkOPs::processTransaction(Transaction::pointer trans,
{
LoadEvent::autoptr ev = theApp->getJobQueue().getLoadEventAP(jtTXN_PROC, "ProcessTXN");
int newFlags = theApp->getSuppression().getFlags(trans->getID());
int newFlags = theApp->getHashRouter().getFlags(trans->getID());
if ((newFlags & SF_BAD) != 0)
{ // cached bad
trans->setStatus(INVALID);
@@ -392,7 +392,7 @@ Transaction::pointer NetworkOPs::processTransaction(Transaction::pointer trans,
if (didApply || (mMode != omFULL))
{
std::set<uint64> peers;
if (theApp->getSuppression().swapSet(trans->getID(), peers, SF_RELAYED))
if (theApp->getHashRouter().swapSet(trans->getID(), peers, SF_RELAYED))
{
ripple::TMTransaction tx;
Serializer s;
@@ -921,7 +921,7 @@ void NetworkOPs::processTrustedProposal(LedgerProposal::pointer proposal,
if (relay)
{
std::set<uint64> peers;
theApp->getSuppression().swapSet(proposal->getSuppression(), peers, SF_RELAYED);
theApp->getHashRouter().swapSet(proposal->getHashRouter(), peers, SF_RELAYED);
PackedMessage::pointer message = boost::make_shared<PackedMessage>(*set, ripple::mtPROPOSE_LEDGER);
theApp->getConnectionPool().relayMessageBut(peers, message);
}

27
src/cpp/ripple/NetworkStatus.h
View File

@@ -1,27 +0,0 @@
#ifndef __NETWORKSTATUS__
#define __NETWORKSTATUS__
struct NSBit
{ // a network status bit
const char *name, *description;
int number;
};
struct NetworkStatus
{
static const int nsbConnected=0; // connected to the network
static const int nsbAccepted=1; // accept this as the real network
static const int nsbFastSynching=2; // catching up, skipping transactions
static const int nsbSlowSynching=3; // catching up, txn by txn
static const int nsbSynched=4; // in synch with the network
static const int nsbIdentifiable=5; // not hiding our identity
static const int nsbLedgerSync=6; // participating in ledger sync
static const int nsbStuck=7; // unable to sync
static const int nsbShuttingDown=8; // node is shutting down
static const int nnbCount=32;
std::bitset<nnbCount> nsbValues;
std::map<int,NSBit> nsbData;
};
#endif

10
src/cpp/ripple/Peer.cpp
View File

@@ -842,12 +842,12 @@ static void checkTransaction(Job&, int flags, SerializedTransaction::pointer stx
tx = boost::make_shared<Transaction>(stx, true);
if (tx->getStatus() == INVALID)
{
theApp->getSuppression().setFlag(stx->getTransactionID(), SF_BAD);
theApp->getHashRouter().setFlag(stx->getTransactionID(), SF_BAD);
Peer::punishPeer(peer, LT_InvalidSignature);
return;
}
else
theApp->getSuppression().setFlag(stx->getTransactionID(), SF_SIGGOOD);
theApp->getHashRouter().setFlag(stx->getTransactionID(), SF_SIGGOOD);
}
else
tx = boost::make_shared<Transaction>(stx, false);
@@ -858,7 +858,7 @@ static void checkTransaction(Job&, int flags, SerializedTransaction::pointer stx
}
catch (...)
{
theApp->getSuppression().setFlags(stx->getTransactionID(), SF_BAD);
theApp->getHashRouter().setFlags(stx->getTransactionID(), SF_BAD);
punishPeer(peer, LT_InvalidRequest);
}
#endif
@@ -962,7 +962,7 @@ static void checkPropose(Job& job, boost::shared_ptr<ripple::TMProposeSet> packe
{ // relay untrusted proposal
WriteLog (lsTRACE, Peer) << "relaying untrusted proposal";
std::set<uint64> peers;
theApp->getSuppression().swapSet(proposal->getSuppression(), peers, SF_RELAYED);
theApp->getHashRouter().swapSet(proposal->getHashRouter(), peers, SF_RELAYED);
PackedMessage::pointer message = boost::make_shared<PackedMessage>(set, ripple::mtPROPOSE_LEDGER);
theApp->getConnectionPool().relayMessageBut(peers, message);
}
@@ -1069,7 +1069,7 @@ static void checkValidation(Job&, SerializedValidation::pointer val, uint256 sig
std::set<uint64> peers;
if (theApp->getOPs().recvValidation(val, source) &&
theApp->getSuppression().swapSet(signingHash, peers, SF_RELAYED))
theApp->getHashRouter().swapSet(signingHash, peers, SF_RELAYED))
{
PackedMessage::pointer message = boost::make_shared<PackedMessage>(*packet, ripple::mtVALIDATION);
theApp->getConnectionPool().relayMessageBut(peers, message);

118
src/cpp/ripple/Suppression.cpp
View File

@@ -1,118 +0,0 @@
#include "Suppression.h"
#include <boost/foreach.hpp>
DECLARE_INSTANCE(Suppression);
Suppression& SuppressionTable::findCreateEntry(const uint256& index, bool& created)
{
boost::unordered_map<uint256, Suppression>::iterator fit = mSuppressionMap.find(index);
if (fit != mSuppressionMap.end())
{
created = false;
return fit->second;
}
created = true;
int now = UptimeTimer::getInstance().getElapsedSeconds ();
int expireTime = now - mHoldTime;
// See if any supressions need to be expired
std::map< int, std::list<uint256> >::iterator it = mSuppressionTimes.begin();
if ((it != mSuppressionTimes.end()) && (it->first <= expireTime))
{
BOOST_FOREACH(const uint256& lit, it->second)
mSuppressionMap.erase(lit);
mSuppressionTimes.erase(it);
}
mSuppressionTimes[now].push_back(index);
return mSuppressionMap.emplace(index, Suppression()).first->second;
}
bool SuppressionTable::addSuppression(const uint256& index)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
findCreateEntry(index, created);
return created;
}
Suppression SuppressionTable::getEntry(const uint256& index)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
return findCreateEntry(index, created);
}
bool SuppressionTable::addSuppressionPeer(const uint256& index, uint64 peer)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
findCreateEntry(index, created).addPeer(peer);
return created;
}
bool SuppressionTable::addSuppressionPeer(const uint256& index, uint64 peer, int& flags)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
Suppression &s = findCreateEntry(index, created);
s.addPeer(peer);
flags = s.getFlags();
return created;
}
int SuppressionTable::getFlags(const uint256& index)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
return findCreateEntry(index, created).getFlags();
}
bool SuppressionTable::addSuppressionFlags(const uint256& index, int flag)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
findCreateEntry(index, created).setFlag(flag);
return created;
}
bool SuppressionTable::setFlag(const uint256& index, int flag)
{ // return: true = changed, false = unchanged
assert(flag != 0);
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
Suppression &s = findCreateEntry(index, created);
if ((s.getFlags() & flag) == flag)
return false;
s.setFlag(flag);
return true;
}
bool SuppressionTable::swapSet(const uint256& index, std::set<uint64>& peers, int flag)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
Suppression &s = findCreateEntry(index, created);
if ((s.getFlags() & flag) == flag)
return false;
s.swapSet(peers);
s.setFlag(flag);
return true;
}

73
src/cpp/ripple/Suppression.h
View File

@@ -1,73 +0,0 @@
#ifndef __SUPPRESSION__
#define __SUPPRESSION__
#include <set>
#include <map>
#include <list>
#include <boost/unordered_map.hpp>
#include <boost/thread/mutex.hpp>
DEFINE_INSTANCE(Suppression);
#define SF_RELAYED 0x01 // Has already been relayed to other nodes
#define SF_BAD 0x02 // Signature/format is bad
#define SF_SIGGOOD 0x04 // Signature is good
#define SF_SAVED 0x08
#define SF_RETRY 0x10 // Transaction can be retried
#define SF_TRUSTED 0x20 // comes from trusted source
class Suppression : private IS_INSTANCE(Suppression)
{
protected:
int mFlags;
std::set<uint64> mPeers;
public:
Suppression() : mFlags(0) { ; }
const std::set<uint64>& peekPeers() { return mPeers; }
void addPeer(uint64 peer) { if (peer != 0) mPeers.insert(peer); }
bool hasPeer(uint64 peer) { return mPeers.count(peer) > 0; }
int getFlags(void) { return mFlags; }
bool hasFlag(int f) { return (mFlags & f) != 0; }
void setFlag(int f) { mFlags |= f; }
void clearFlag(int f) { mFlags &= ~f; }
void swapSet(std::set<uint64>& s) { mPeers.swap(s); }
};
class SuppressionTable
{
protected:
boost::mutex mSuppressionMutex;
// Stores all suppressed hashes and their expiration time
boost::unordered_map<uint256, Suppression> mSuppressionMap;
// Stores all expiration times and the hashes indexed for them
std::map< int, std::list<uint256> > mSuppressionTimes;
int mHoldTime;
Suppression& findCreateEntry(const uint256&, bool& created);
public:
SuppressionTable(int holdTime = 120) : mHoldTime(holdTime) { ; }
bool addSuppression(const uint256& index);
bool addSuppressionPeer(const uint256& index, uint64 peer);
bool addSuppressionPeer(const uint256& index, uint64 peer, int& flags);
bool addSuppressionFlags(const uint256& index, int flag);
bool setFlag(const uint256& index, int flag);
int getFlags(const uint256& index);
Suppression getEntry(const uint256&);
bool swapSet(const uint256& index, std::set<uint64>& peers, int flag);
bool swapSet(const uint256& index, std::set<uint64>& peers);
};
#endif

155
src/cpp/ripple/ripple_HashRouter.cpp Normal file
View File

@@ -0,0 +1,155 @@
DECLARE_INSTANCE(HashRouterEntry);
// VFALCO: TODO Inline the function definitions
class HashRouter : public IHashRouter
{
public:
explicit HashRouter (int holdTime)
: mHoldTime (holdTime)
{
}
bool addSuppression(const uint256& index);
bool addSuppressionPeer(const uint256& index, uint64 peer);
bool addSuppressionPeer(const uint256& index, uint64 peer, int& flags);
bool addSuppressionFlags(const uint256& index, int flag);
bool setFlag(const uint256& index, int flag);
int getFlags(const uint256& index);
HashRouterEntry getEntry(const uint256&);
bool swapSet(const uint256& index, std::set<uint64>& peers, int flag);
private:
boost::mutex mSuppressionMutex;
// Stores all suppressed hashes and their expiration time
boost::unordered_map <uint256, HashRouterEntry> mSuppressionMap;
// Stores all expiration times and the hashes indexed for them
std::map< int, std::list<uint256> > mSuppressionTimes;
int mHoldTime;
HashRouterEntry& findCreateEntry(const uint256&, bool& created);
};
HashRouterEntry& HashRouter::findCreateEntry(const uint256& index, bool& created)
{
boost::unordered_map<uint256, HashRouterEntry>::iterator fit = mSuppressionMap.find(index);
if (fit != mSuppressionMap.end())
{
created = false;
return fit->second;
}
created = true;
int now = UptimeTimer::getInstance().getElapsedSeconds ();
int expireTime = now - mHoldTime;
// See if any supressions need to be expired
std::map< int, std::list<uint256> >::iterator it = mSuppressionTimes.begin();
if ((it != mSuppressionTimes.end()) && (it->first <= expireTime))
{
BOOST_FOREACH(const uint256& lit, it->second)
mSuppressionMap.erase(lit);
mSuppressionTimes.erase(it);
}
mSuppressionTimes[now].push_back(index);
return mSuppressionMap.emplace(index, HashRouterEntry ()).first->second;
}
bool HashRouter::addSuppression(const uint256& index)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
findCreateEntry(index, created);
return created;
}
HashRouterEntry HashRouter::getEntry(const uint256& index)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
return findCreateEntry(index, created);
}
bool HashRouter::addSuppressionPeer(const uint256& index, uint64 peer)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
findCreateEntry(index, created).addPeer(peer);
return created;
}
bool HashRouter::addSuppressionPeer(const uint256& index, uint64 peer, int& flags)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
HashRouterEntry &s = findCreateEntry(index, created);
s.addPeer(peer);
flags = s.getFlags();
return created;
}
int HashRouter::getFlags(const uint256& index)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
return findCreateEntry(index, created).getFlags();
}
bool HashRouter::addSuppressionFlags(const uint256& index, int flag)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
findCreateEntry(index, created).setFlag(flag);
return created;
}
bool HashRouter::setFlag(const uint256& index, int flag)
{ // return: true = changed, false = unchanged
assert(flag != 0);
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
HashRouterEntry &s = findCreateEntry(index, created);
if ((s.getFlags() & flag) == flag)
return false;
s.setFlag(flag);
return true;
}
bool HashRouter::swapSet(const uint256& index, std::set<uint64>& peers, int flag)
{
boost::mutex::scoped_lock sl(mSuppressionMutex);
bool created;
HashRouterEntry &s = findCreateEntry(index, created);
if ((s.getFlags() & flag) == flag)
return false;
s.swapSet(peers);
s.setFlag(flag);
return true;
}
IHashRouter* IHashRouter::New (int holdTime)
{
return new HashRouter (holdTime);
}

65
src/cpp/ripple/ripple_IHashRouter.h Normal file
View File

@@ -0,0 +1,65 @@
#ifndef RIPPLE_HASHROUTER_H
#define RIPPLE_HASHROUTER_H
DEFINE_INSTANCE (HashRouterEntry);
// VFALCO: TODO, convert these macros to int constants
#define SF_RELAYED 0x01 // Has already been relayed to other nodes
#define SF_BAD 0x02 // Signature/format is bad
#define SF_SIGGOOD 0x04 // Signature is good
#define SF_SAVED 0x08
#define SF_RETRY 0x10 // Transaction can be retried
#define SF_TRUSTED 0x20 // comes from trusted source
// VFALCO: TODO move this class into the scope of class HashRouter
class HashRouterEntry : private IS_INSTANCE (HashRouterEntry)
{
protected:
int mFlags;
std::set<uint64> mPeers;
public:
HashRouterEntry () : mFlags(0) { ; }
const std::set<uint64>& peekPeers() { return mPeers; }
void addPeer(uint64 peer) { if (peer != 0) mPeers.insert(peer); }
bool hasPeer(uint64 peer) { return mPeers.count(peer) > 0; }
int getFlags(void) { return mFlags; }
bool hasFlag(int f) { return (mFlags & f) != 0; }
void setFlag(int f) { mFlags |= f; }
void clearFlag(int f) { mFlags &= ~f; }
void swapSet(std::set<uint64>& s) { mPeers.swap(s); }
};
class IHashRouter
{
public:
// VFALCO: NOTE, this preferred alternative to default parameters makes
// behavior clear.
//
static inline int getDefaultHoldTime ()
{
return 120;
}
// VFALCO: TODO rename the parameter to entryHoldTimeInSeconds
static IHashRouter* New (int holdTime);
virtual ~IHashRouter () { }
virtual bool addSuppression(const uint256& index) = 0;
virtual bool addSuppressionPeer(const uint256& index, uint64 peer) = 0;
virtual bool addSuppressionPeer(const uint256& index, uint64 peer, int& flags) = 0;
virtual bool addSuppressionFlags(const uint256& index, int flag) = 0;
virtual bool setFlag(const uint256& index, int flag) = 0;
virtual int getFlags(const uint256& index) = 0;
virtual HashRouterEntry getEntry(const uint256&) = 0;
virtual bool swapSet(const uint256& index, std::set<uint64>& peers, int flag) = 0;
};
#endif