2014 network limit 1.3 fix log/path/data +utils

+toc -doc -drmonero

Fixed the windows path, and improved logging and data
(for graph) logging, fixed some locks and added more checks.

Still there is a locking error,
not added by my patches, but present in master version
(locking of map/list of peers).

4 files changed, 137 insertions, 60 deletions

diff --git a/src/p2p/connection_basic.cpp b/src/p2p/connection_basic.cpp
index 4a4a32384..ed15c0986 100644
--- a/src/p2p/connection_basic.cpp
+++ b/src/p2p/connection_basic.cpp
@@ -272,6 +272,7 @@ void connection_basic::logger_handle_net_write(size_t size) {
 }
 
 double connection_basic::get_sleep_time(size_t cb) {
+	CRITICAL_REGION_LOCAL(epee::net_utils::network_throttle_manager::network_throttle_manager::m_lock_get_global_throttle_out);
     auto t = network_throttle_manager::get_global_throttle_out().get_sleep_time(cb);
     return t;
 }
diff --git a/src/p2p/data_logger.cpp b/src/p2p/data_logger.cpp
index 77f647bed..d62af133e 100644
--- a/src/p2p/data_logger.cpp
+++ b/src/p2p/data_logger.cpp
@@ -1,4 +1,5 @@
 #include "data_logger.hpp"
+#include <stdexcept>
 
 #include <boost/chrono.hpp>
 #include <boost/filesystem.hpp>
@@ -9,25 +10,25 @@ namespace epee
 {
 namespace net_utils
 {
-	data_logger &data_logger::get_instance()
-	{
-		static data_logger instance;
-		return instance;
+	data_logger &data_logger::get_instance() {
+		std::call_once(m_singleton, 
+			[] { 
+				_info_c("dbg/data","Creating singleton of data_logger");
+				if (m_state != data_logger_state::state_before_init) { _erro_c("dbg/data","Internal error in singleton"); throw std::runtime_error("data_logger singleton"); }
+				m_state = data_logger_state::state_during_init;
+				m_obj.reset(new data_logger());
+				m_state = data_logger_state::state_ready_to_use;
+			}	
+		);
+		return * m_obj;
 	}
 	
-	data_logger::data_logger()
-	{
-		//create timer
-		std::shared_ptr<std::thread> logger_thread(new std::thread([&]()
-		{
-			while (true)
-			{
-				std::this_thread::sleep_for(std::chrono::seconds(1));
-				saveToFile();
-			}
-		}));
-		logger_thread->detach();
+	data_logger::data_logger() {
+		_warn_c("dbg/data","Starting data logger (for graphs data)");
+		if (m_state != data_logger_state::state_during_init) { _erro_c("dbg/data","Singleton ctor state"); throw std::runtime_error("data_logger ctor state"); }
+		std::lock_guard<std::mutex> lock(mMutex); // lock
 		
+		// prepare all the files for given data channels:
 		mFilesMap["peers"] = data_logger::fileData("log/dr-monero/peers.data");
 		mFilesMap["download"] = data_logger::fileData("log/dr-monero/net/in-all.data");
 		mFilesMap["upload"] = data_logger::fileData("log/dr-monero/net/out-all.data");
@@ -44,25 +45,80 @@ namespace net_utils
 		mFilesMap["peers_limit"].mLimitFile = true;
 		mFilesMap["download_limit"].mLimitFile = true;
 		mFilesMap["upload_limit"].mLimitFile = true;
+
+		// do NOT modify mFilesMap below this point, since there is no locking for this used (yet)
+
+		_note_c("dbg/data","Creating thread for data logger"); // create timer thread
+		m_thread_maybe_running=true;
+		std::shared_ptr<std::thread> logger_thread(new std::thread([&]() {
+			_note_c("dbg/data","Inside thread for data logger");
+			while (m_state == data_logger_state::state_during_init) { // wait for creation to be done (in other thread, in singleton) before actually running
+				std::this_thread::sleep_for(std::chrono::seconds(1));
+			}
+			_note_c("dbg/data","Inside thread for data logger - going into main loop");
+			while (m_state == data_logger_state::state_ready_to_use) { // run as long as we are not closing the single object
+				std::this_thread::sleep_for(std::chrono::seconds(1));
+				saveToFile(); // save all the pending data
+			}
+			_note_c("dbg/data","Inside thread for data logger - done the main loop");
+			m_thread_maybe_running=false;
+		}));
+		logger_thread->detach();
+		_info_c("dbg/data","Data logger constructed");
+	}
+
+	data_logger::~data_logger() {
+		_note_c("dbg/data","Destructor of the data logger");
+		{
+			std::lock_guard<std::mutex> lock(mMutex);
+			m_state = data_logger_state::state_dying;
+		}
+		_info_c("dbg/data","State was set to dying");
+		while(m_thread_maybe_running) { // wait for the thread to exit
+			std::this_thread::sleep_for(std::chrono::seconds(1));
+			_info_c("dbg/data","Waiting for background thread to exit");
+		}
+		_info_c("dbg/data","Thread exited");
+	}
+
+	void data_logger::kill_instance() { 
+		m_state = m_state = data_logger_state::state_dying;
+		m_obj.reset();
 	}
 	
-	void data_logger::add_data(std::string filename, unsigned int data)
-	{
-		if (mFilesMap.find(filename) == mFilesMap.end())
-			return; // TODO: exception
-			
-		
-		nOT::nUtils::cFilesystemUtils::CreateDirTree("log/dr-monero/net/");
+	void data_logger::add_data(std::string filename, unsigned int data) {
+		std::lock_guard<std::mutex> lock(mMutex);
+		if (m_state != data_logger_state::state_ready_to_use) { _info_c("dbg/data","Data logger is not ready, returning."); return; }
+
+		if (mFilesMap.find(filename) == mFilesMap.end()) { // no such file/counter
+			_erro_c("dbg/data","Trying to use not opened data file filename="<<filename);
+			_erro_c("dbg/data","Disabling saving of graphs due to error");
+			m_save_graph=false; // <--- disabling saving graphs
+			return;
+		}
 		
-		std::lock_guard<std::mutex> lock(mSaveMutex);
-		if (mFilesMap[filename].mLimitFile)
+		if (mFilesMap[filename].mLimitFile) { // this holds a number (that is not additive) - e.g. the limit setting
 			mFilesMap[filename].mDataToSave = data;
-		else
-			mFilesMap[filename].mDataToSave += data;
+		} else {
+			mFilesMap[filename].mDataToSave += data; // this holds a number that should be sum of all accumulated samples
+		}
+	}
+
+	void data_logger::saveToFile() {
+		_dbg2_c("dbg/data","saving to files");
+		std::lock_guard<std::mutex> lock(mMutex);
+		if (m_state != data_logger_state::state_ready_to_use) { _info_c("dbg/data","Data logger is not ready, returning."); return; }
+		nOT::nUtils::cFilesystemUtils::CreateDirTree("log/dr-monero/net/");
+		for (auto &element : mFilesMap)
+		{
+			element.second.save();
+			if (!element.second.mLimitFile) element.second.mDataToSave = 0;
+		}
 	}
+
+	// the inner class:
 	
-	double data_logger::fileData::get_current_time()
-	{
+	double data_logger::fileData::get_current_time() {
 		using namespace boost::chrono;
 		auto point = steady_clock::now();
 		auto time_from_epoh = point.time_since_epoch();
@@ -71,33 +127,28 @@ namespace net_utils
 		return ms_f / 1000.;
 	}
 	
-	data_logger::fileData::fileData(std::string pFile)
-	{
+	data_logger::fileData::fileData(std::string pFile) {
+		_dbg3_c("dbg/data","opening data file named pFile="<<pFile<<" for this="<<this);
 		mFile = std::make_shared<std::ofstream> (pFile);
+		_dbg1_c("dbg/data","opened data file named pFile="<<pFile<<" in mFile="<<mFile<<" for this="<<this);
 		mPath = pFile;
 	}
 	
-	void data_logger::fileData::save()
-	{
-		if (!data_logger::m_save_graph)
-			return;
+	void data_logger::fileData::save() {
+		if (!data_logger::m_save_graph) return; // <--- disabled
+		_dbg2_c("dbg/data","saving to the file now, mFile="<<mFile);
 		mFile->open(mPath, std::ios::app);
 		*mFile << static_cast<int>(get_current_time()) << " " << mDataToSave << std::endl;
 		mFile->close();
 	}
 	
-	void data_logger::saveToFile()
-	{
-		std::lock_guard<std::mutex> lock(mSaveMutex);
-		for (auto &element : mFilesMap)
-		{
-			element.second.save();
-			if (!element.second.mLimitFile)
-				element.second.mDataToSave = 0;
-		}
-	}
 	
-std::atomic<bool> data_logger::m_save_graph(false);
+data_logger_state data_logger::m_state(data_logger_state::state_before_init); ///< (static) state of the singleton object
+std::atomic<bool> data_logger::m_save_graph(false); // (static)
+std::atomic<bool> data_logger::m_thread_maybe_running(false); // (static)
+std::once_flag data_logger::m_singleton; // (static)
+std::unique_ptr<data_logger> data_logger::m_obj; // (static)
 
 } // namespace
 } // namespace
+
diff --git a/src/p2p/data_logger.hpp b/src/p2p/data_logger.hpp
index 50beb847a..215912167 100644
--- a/src/p2p/data_logger.hpp
+++ b/src/p2p/data_logger.hpp
@@ -13,34 +13,60 @@ namespace epee
 {
 namespace net_utils
 {
+
+enum class data_logger_state { state_before_init, state_during_init, state_ready_to_use, state_dying };
 	
+/***
+@note: use it ONLY via singleton! It will be spawned then, and will auto destruct on program exit.
+@note: do call ::kill_instance() before exiting main, at end of main. But before make sure no one else (e.g. no other threads) will try to use this/singleton
+@note: it is not allowed to use this class from code "runnig before or after main", e.g. from ctors of static objects, because of static-creation-order races
+@note: on creation (e.g. from singleton), it spawns a thread that saves all data in background
+*/
 	class data_logger {
 		public:
-			static data_logger &get_instance();
-			data_logger(const data_logger &ob) = delete;
+			static data_logger &get_instance(); ///< singleton
+			static void kill_instance(); ///< call this before ending main to allow more gracefull shutdown of the main singleton and it's background thread
+			~data_logger(); ///< destr, will be called when singleton is killed when global m_obj dies. will kill theads etc
+
+		private:
+			data_logger(); ///< constructor is private, use only via singleton get_instance
+
+		public:
+			data_logger(const data_logger &ob) = delete; // use only one per program
 			data_logger(data_logger &&ob) = delete;
-			void add_data(std::string filename, unsigned int data);
-			static std::atomic<bool> m_save_graph;
+			data_logger & operator=(const data_logger&) = delete;
+			data_logger & operator=(data_logger&&) = delete;
+
+			void add_data(std::string filename, unsigned int data); ///< use this to append data here. Use it only the singleton. It locks itself.
+
+			static std::atomic<bool> m_save_graph; ///< global setting flag, should we save all the data or not (can disable logging graphs data)
+
 		private:
-			data_logger();
-			class fileData
-			{
+			static std::once_flag m_singleton; ///< to guarantee singleton creates the object exactly once
+			static data_logger_state m_state; ///< state of the singleton object
+			static std::atomic<bool> m_thread_maybe_running; ///< is the background thread (more or less) running, or is it fully finished
+			static std::unique_ptr<data_logger> m_obj; ///< the singleton object. Only use it via get_instance(). Can be killed by kill_instance()
+
+			/***
+			* one graph/file with data
+			*/
+			class fileData {
 				public:
-					fileData(){}
+					fileData() = default;
 					fileData(const fileData &ob) = delete;
 					fileData(std::string pFile);
 					
 					std::shared_ptr<std::ofstream> mFile;
-					long int mDataToSave = 0;
+					long int mDataToSave = 0; ///< sum of the data (in current interval, will be counted from 0 on next interval)
 					static double get_current_time();
 					void save();
 					std::string mPath;
-					bool mLimitFile = false;
+					bool mLimitFile = false; ///< this holds a number (that is not additive) - e.g. the limit setting
 			};
 			
-			std::map <std::string, fileData> mFilesMap;
-			std::mutex mSaveMutex;
-			void saveToFile();
+			std::map<std::string, fileData> mFilesMap;
+			std::mutex mMutex;
+			void saveToFile(); ///< write data to the target files. do not use this directly
 	};
 	
 } // namespace
diff --git a/src/p2p/network_throttle.cpp b/src/p2p/network_throttle.cpp
index 3d5edcdcd..7bc89881d 100644
--- a/src/p2p/network_throttle.cpp
+++ b/src/p2p/network_throttle.cpp
@@ -78,7 +78,6 @@ int network_throttle_manager::xxx;
 // ================================================================================================
 // methods:
 i_network_throttle & network_throttle_manager::get_global_throttle_in() { 
-
 	std::call_once(m_once_get_global_throttle_in, [] { m_obj_get_global_throttle_in.reset(new network_throttle("in/all","<<< global-IN",10)); }	);
 	return * m_obj_get_global_throttle_in;
 }