Merge branch 'master' of github.com:jedmccaleb/NewCoin into notdone

src/cpp/ripple/Application.cpp

@@ -71,8 +71,24 @@ static void InitDB(DatabaseCon** dbCon, const char *fileName, const char *dbInit
 	*dbCon = new DatabaseCon(fileName, dbInit, dbCount);
 }
 
+volatile bool doShutdown = false;
+
+#ifdef SIGINT
+void sigIntHandler(int)
+{
+	doShutdown = true;
+}
+#endif
+
 void Application::run()
 {
+#ifdef SIGINT
+	struct sigaction sa;
+	memset(&sa, 0, sizeof(sa));
+	sa.sa_handler = sigIntHandler;
+	sigaction(SIGINT, &sa, NULL);
+#endif
+
 	assert(mTxnDB == NULL);
 	if (!theConfig.DEBUG_LOGFILE.empty())
 	{ // Let DEBUG messages go to the file but only WARNING or higher to regular output (unless verbose)

src/cpp/ripple/Application.h

@@ -35,7 +35,7 @@ public:
 	DatabaseCon(const std::string& name, const char *initString[], int countInit);
 	~DatabaseCon();
 	Database* getDB() { return mDatabase; }
-	ScopedLock getDBLock() { return ScopedLock(mLock); }
+	boost::recursive_mutex& getDBLock() { return mLock; }
 };
 
 class Application

src/cpp/ripple/HashedObject.cpp

@@ -12,7 +12,7 @@ SETUP_LOG();
 DECLARE_INSTANCE(HashedObject);
 
 HashedObjectStore::HashedObjectStore(int cacheSize, int cacheAge) :
-	mCache("HashedObjectStore", cacheSize, cacheAge), mWritePending(false)
+	mCache("HashedObjectStore", cacheSize, cacheAge), mWriteGeneration(0), mWritePending(false)
 {
 	mWriteSet.reserve(128);
 }
@@ -53,27 +53,29 @@ bool HashedObjectStore::store(HashedObjectType type, uint32 index,
 
 void HashedObjectStore::waitWrite()
 {
-	boost::unique_lock<boost::mutex> sl(mWriteMutex);
-	while (mWritePending)
+	boost::mutex::scoped_lock sl(mWriteMutex);
+	int gen = mWriteGeneration;
+	while (mWritePending && (mWriteGeneration == gen))
 		mWriteCondition.wait(sl);
 }
 
 void HashedObjectStore::bulkWrite()
 {
-	LoadEvent::pointer event = theApp->getJobQueue().getLoadEvent(jtDISK);
+	LoadEvent::autoptr event(theApp->getJobQueue().getLoadEventAP(jtDISK));
 	while (1)
 	{
 		std::vector< boost::shared_ptr<HashedObject> > set;
 		set.reserve(128);
 
 		{
-			boost::unique_lock<boost::mutex> sl(mWriteMutex);
+			boost::mutex::scoped_lock sl(mWriteMutex);
 			mWriteSet.swap(set);
 			assert(mWriteSet.empty());
+			++mWriteGeneration;
+			mWriteCondition.notify_all();
 			if (set.empty())
 			{
 				mWritePending = false;
-				mWriteCondition.notify_all();
 				return;
 			}
 		}
@@ -85,7 +87,7 @@ void HashedObjectStore::bulkWrite()
 
 		Database* db = theApp->getHashNodeDB()->getDB();
 		{
-			ScopedLock sl = theApp->getHashNodeDB()->getDBLock();
+			ScopedLock sl( theApp->getHashNodeDB()->getDBLock());
 
 			db->executeSQL("BEGIN TRANSACTION;");
 

src/cpp/ripple/HashedObject.h

@@ -49,6 +49,7 @@ protected:
 
 	boost::mutex				mWriteMutex;
 	boost::condition_variable	mWriteCondition;
+	int							mWriteGeneration;
 
 	std::vector< boost::shared_ptr<HashedObject> > mWriteSet;
 	bool mWritePending;

src/cpp/ripple/JobQueue.h

@@ -104,6 +104,8 @@ public:
 
 	LoadEvent::pointer getLoadEvent(JobType t)
 	{ return boost::make_shared<LoadEvent>(boost::ref(mJobLoads[t]), true, 1); }
+	LoadEvent::autoptr getLoadEventAP(JobType t)
+	{ return LoadEvent::autoptr(new LoadEvent(mJobLoads[t], true, 1)); }
 
 	Json::Value getJson(int c = 0);
 };

src/cpp/ripple/Ledger.cpp

@@ -299,6 +299,29 @@ SerializedTransaction::pointer Ledger::getSTransaction(SHAMapItem::ref item, SHA
 	return SerializedTransaction::pointer();
 }
 
+SerializedTransaction::pointer Ledger::getSMTransaction(SHAMapItem::ref item, SHAMapTreeNode::TNType type,
+	TransactionMetaSet::pointer& txMeta)
+{
+	SerializerIterator sit(item->peekSerializer());
+
+	if (type == SHAMapTreeNode::tnTRANSACTION_NM)
+	{
+		txMeta.reset();
+		return boost::make_shared<SerializedTransaction>(boost::ref(sit));
+	}
+	else if (type == SHAMapTreeNode::tnTRANSACTION_MD)
+	{
+		Serializer sTxn(sit.getVL());
+		SerializerIterator tSit(sTxn);
+
+		txMeta = boost::make_shared<TransactionMetaSet>(item->getTag(), mLedgerSeq, sit.getVL());
+		return boost::make_shared<SerializedTransaction>(boost::ref(tSit));
+	}
+
+	txMeta.reset();
+	return SerializedTransaction::pointer();
+}
+
 bool Ledger::getTransaction(const uint256& txID, Transaction::pointer& txn, TransactionMetaSet::pointer& meta)
 {
 	SHAMapTreeNode::TNType type;
@@ -339,9 +362,8 @@ uint256 Ledger::getHash()
 	return mHash;
 }
 
-void Ledger::saveAcceptedLedger(bool fromConsensus)
+void Ledger::saveAcceptedLedger(bool fromConsensus, LoadEvent::pointer event)
 { // can be called in a different thread
-	LoadEvent::pointer event = theApp->getJobQueue().getLoadEvent(jtDISK);
 	cLog(lsTRACE) << "saveAcceptedLedger " << (fromConsensus ? "fromConsensus " : "fromAcquire ") << getLedgerSeq();
 	static boost::format ledgerExists("SELECT LedgerSeq FROM Ledgers where LedgerSeq = %d;");
 	static boost::format deleteLedger("DELETE FROM Ledgers WHERE LedgerSeq = %d;");
@@ -369,7 +391,7 @@ void Ledger::saveAcceptedLedger(bool fromConsensus)
 
 		SHAMap& txSet = *peekTransactionMap();
 		Database *db = theApp->getTxnDB()->getDB();
-		ScopedLock dbLock = theApp->getTxnDB()->getDBLock();
+		ScopedLock dbLock(theApp->getTxnDB()->getDBLock());
 		db->executeSQL("BEGIN TRANSACTION;");
 		SHAMapTreeNode::TNType type;
 		for (SHAMapItem::pointer item = txSet.peekFirstItem(type); !!item;
@@ -439,7 +461,7 @@ void Ledger::saveAcceptedLedger(bool fromConsensus)
 	}
 
 	theApp->getLedgerMaster().setFullLedger(shared_from_this());
-	event = LoadEvent::pointer();
+	event->stop();
 
 	theApp->getOPs().pubLedger(shared_from_this());
 
@@ -1136,7 +1158,8 @@ void Ledger::pendSave(bool fromConsensus)
 	if (!fromConsensus && !theApp->isNewFlag(getHash(), SF_SAVED))
 		return;
 
-	boost::thread thread(boost::bind(&Ledger::saveAcceptedLedger, shared_from_this(), fromConsensus));
+	boost::thread thread(boost::bind(&Ledger::saveAcceptedLedger, shared_from_this(),
+		fromConsensus, theApp->getJobQueue().getLoadEvent(jtDISK)));
 	thread.detach();
 
 	boost::recursive_mutex::scoped_lock sl(sPendingSaveLock);

src/cpp/ripple/Ledger.h

@@ -19,6 +19,7 @@
 #include "BitcoinUtil.h"
 #include "SHAMap.h"
 #include "InstanceCounter.h"
+#include "LoadMonitor.h"
 
 enum LedgerStateParms
 {
@@ -93,7 +94,7 @@ protected:
 
 	static void incPendingSaves();
 	static void decPendingSaves();
-	void saveAcceptedLedger(bool fromConsensus);
+	void saveAcceptedLedger(bool fromConsensus, LoadEvent::pointer);
 
 public:
 	Ledger(const RippleAddress& masterID, uint64 startAmount); // used for the starting bootstrap ledger
@@ -160,7 +161,10 @@ public:
 	bool hasTransaction(const uint256& TransID) const { return mTransactionMap->hasItem(TransID); }
 	Transaction::pointer getTransaction(const uint256& transID) const;
 	bool getTransaction(const uint256& transID, Transaction::pointer& txn, TransactionMetaSet::pointer& txMeta);
+
 	static SerializedTransaction::pointer getSTransaction(SHAMapItem::ref, SHAMapTreeNode::TNType);
+	SerializedTransaction::pointer getSMTransaction(SHAMapItem::ref, SHAMapTreeNode::TNType,
+	 TransactionMetaSet::pointer& txMeta);
 
 	// high-level functions
 	AccountState::pointer getAccountState(const RippleAddress& acctID);

src/cpp/ripple/LedgerConsensus.cpp

@@ -644,8 +644,16 @@ void LedgerConsensus::stateAccepted()
 	endConsensus();
 }
 
+extern volatile bool doShutdown;
+
 void LedgerConsensus::timerEntry()
 {
+	if (doShutdown)
+	{
+		cLog(lsFATAL) << "Shutdown requested";
+		theApp->stop();
+	}
+
 	if ((mState != lcsFINISHED) && (mState != lcsACCEPTED))
 		checkLCL();
 
@@ -1251,7 +1259,7 @@ void LedgerConsensus::accept(SHAMap::ref set, LoadEvent::pointer)
 		cLog(lsINFO) << "CNF newLCL " << newLCLHash;
 
 	Ledger::pointer newOL = boost::make_shared<Ledger>(true, boost::ref(*newLCL));
-	ScopedLock sl = theApp->getLedgerMaster().getLock();
+	ScopedLock sl( theApp->getLedgerMaster().getLock());
 
 	// Apply disputed transactions that didn't get in
 	TransactionEngine engine(newOL);

src/cpp/ripple/LoadMonitor.h

@@ -37,6 +37,7 @@ class LoadEvent
 {
 public:
 	typedef boost::shared_ptr<LoadEvent>	pointer;
+	typedef std::auto_ptr<LoadEvent>		autoptr;
 
 protected:
 	LoadMonitor&				mMonitor;

src/cpp/ripple/NetworkOPs.cpp

@@ -889,7 +889,7 @@ std::vector< std::pair<Transaction::pointer, TransactionMetaSet::pointer> >
 
 	{
 		Database* db = theApp->getTxnDB()->getDB();
-		ScopedLock dbLock = theApp->getTxnDB()->getDBLock();
+		ScopedLock sl(theApp->getTxnDB()->getDBLock());
 
 		SQL_FOREACH(db, sql)
 		{
@@ -923,7 +923,7 @@ std::vector<RippleAddress>
 	RippleAddress acct;
 	{
 		Database* db = theApp->getTxnDB()->getDB();
-		ScopedLock dblock = theApp->getTxnDB()->getDBLock();
+		ScopedLock sl(theApp->getTxnDB()->getDBLock());
 		SQL_FOREACH(db, sql)
 		{
 			if (acct.setAccountID(db->getStrBinary("Account")))
@@ -1016,7 +1016,7 @@ void NetworkOPs::pubLedger(Ledger::ref lpAccepted)
 	if (NetworkOPs::omDISCONNECTED == getOperatingMode())
 		return;
 
-	LoadEvent::pointer event = theApp->getJobQueue().getLoadEvent(jtPUBLEDGER);
+	LoadEvent::autoptr event(theApp->getJobQueue().getLoadEventAP(jtPUBLEDGER));
 
 	{
 		boost::recursive_mutex::scoped_lock	sl(mMonitorLock);

src/cpp/ripple/Peer.cpp

@@ -373,7 +373,7 @@ void Peer::processReadBuffer()
 
 //	std::cerr << "Peer::processReadBuffer: " << mIpPort.first << " " << mIpPort.second << std::endl;
 
-	LoadEvent::pointer event = theApp->getJobQueue().getLoadEvent(jtPEER);
+	LoadEvent::autoptr event(theApp->getJobQueue().getLoadEventAP(jtPEER));
 
 	boost::recursive_mutex::scoped_lock sl(theApp->getMasterLock());
 

src/cpp/ripple/RPCHandler.cpp

@@ -1158,7 +1158,7 @@ Json::Value RPCHandler::doTxHistory(const Json::Value& params)
 
 		{
 			Database* db = theApp->getTxnDB()->getDB();
-			ScopedLock dbLock = theApp->getTxnDB()->getDBLock();
+			ScopedLock sl (theApp->getTxnDB()->getDBLock());
 
 			SQL_FOREACH(db, sql)
 			{
@@ -1475,7 +1475,7 @@ Json::Value RPCHandler::doCommand(const std::string& command, Json::Value& param
 	cLog(lsTRACE) << "RPC:" << command;
 	cLog(lsTRACE) << "RPC params:" << params;
 
-	LoadEvent::pointer le = theApp->getJobQueue().getLoadEvent(jtRPC);
+	LoadEvent::autoptr le(theApp->getJobQueue().getLoadEventAP(jtRPC));
 
 	mRole	= role;
 

src/cpp/ripple/ScopedLock.h

@@ -6,16 +6,18 @@
 #include <boost/make_shared.hpp>
 #include <boost/ref.hpp>
 
+typedef boost::recursive_mutex::scoped_lock ScopedLock;
+
 // A lock holder that can be returned and copied by value
 // When the last reference goes away, the lock is released
 
-class ScopedLock
+class SharedScopedLock
 {
 protected:
 	mutable boost::shared_ptr<boost::recursive_mutex::scoped_lock> mHolder;
 
 public:
-	ScopedLock(boost::recursive_mutex& mutex) :
+	SharedScopedLock(boost::recursive_mutex& mutex) :
 		mHolder(boost::make_shared<boost::recursive_mutex::scoped_lock>(boost::ref(mutex)))	{ ;	}
 
 	void lock() const	{ mHolder->lock(); }

src/cpp/ripple/Transaction.cpp

@@ -146,12 +146,13 @@ bool Transaction::save()
 	 default:			status = TXN_SQL_UNKNOWN;
 	}
 
-	std::string exists = boost::str(boost::format("SELECT Status FROM Transactions WHERE TransID = '%s';")
-		% mTransaction->getTransactionID().GetHex());
+	static boost::format selStat("SELECT Status FROM Transactions WHERE	TransID = '%s';");
+	std::string exists = boost::str(selStat % mTransaction->getTransactionID().GetHex());
 
 	Database *db = theApp->getTxnDB()->getDB();
-	ScopedLock dbLock = theApp->getTxnDB()->getDBLock();
-	if (SQL_EXISTS(db, exists)) return false;
+	ScopedLock dbLock(theApp->getTxnDB()->getDBLock());
+	if (SQL_EXISTS(db, exists))
+		return false;
 	return
 		db->executeSQL(mTransaction->getSQLInsertHeader() + mTransaction->getSQL(getLedger(), status) + ";");
 }

src/cpp/ripple/ValidationCollection.cpp

@@ -289,7 +289,7 @@ void ValidationCollection::condWrite()
 
 void ValidationCollection::doWrite()
 {
-	LoadEvent::pointer event = theApp->getJobQueue().getLoadEvent(jtDISK);
+	LoadEvent::autoptr event(theApp->getJobQueue().getLoadEventAP(jtDISK));
 	static boost::format insVal("INSERT INTO LedgerValidations "
 		"(LedgerHash,NodePubKey,Flags,SignTime,Signature) VALUES ('%s','%s','%u','%u',%s);");
 

src/cpp/ripple/utils.h

@@ -154,7 +154,8 @@ inline std::string strHex(const uint64 uiHost)
 
 inline static std::string sqlEscape(const std::string& strSrc)
 {
-	return str(boost::format("X'%s'") % strHex(strSrc));
+	static boost::format f("X'%s'");
+	return str(f % strHex(strSrc));
 }
 
 template<class Iterator>