PreVerify/lib/qtl/include/qtl_database_pool.hpp

#ifndef _QTL_DATABASE_POOL_H_
#define _QTL_DATABASE_POOL_H_

#include <memory>
#include <vector>
#include <atomic>
#include <thread>
#include <mutex>
#include <chrono>
#include <algorithm>

namespace qtl
{

template<typename Database>
class database_pool
{
public:
	typedef Database value_type;
	typedef std::shared_ptr<Database> pointer;

	database_pool()
		: m_trying_connection(false), m_stop_thread(false)
	{
	}

	virtual ~database_pool()
	{
		if(m_background_thread.joinable())
		{
			m_stop_thread=true;
			try
			{
				m_background_thread.join();
			}
			catch (std::system_error&)
			{
				//igore the error
			}
		}
		clear();
	}

	pointer get()
	{
		Database* db=popup();
		if(db==NULL && m_trying_connection==false)
			db=create_database();
		return pointer(db, [this](Database* db) {
			recovery(db);
		});
	}

	bool test_alive()
	{
		if(m_databases.empty()) 
			return false;
		std::unique_lock<std::mutex> lock(m_pool_mutex);
		auto it=m_databases.begin();
		while(it!=m_databases.end())
		{
			Database* db=*it;
			if(!db->is_alive())
			{
				delete db;
				it=m_databases.erase(it);
			}
			else
			{
				++it;
			}
		}
		if(m_databases.empty())
		{
			lock.unlock();
			try_connect();
			return false;
		}
		else return true;
	}

private:
	std::vector<Database*> m_databases;
	std::mutex m_pool_mutex;
	std::atomic<bool> m_trying_connection;
	std::thread m_background_thread;
	bool m_stop_thread;

	virtual Database* new_database() throw()=0;
	void recovery(Database* db)
	{
		if(db==NULL) return;
		if(db->is_alive())
		{
			std::lock_guard<std::mutex> lock(m_pool_mutex);
			m_databases.push_back(db);
		}
		else
		{
			delete db;
			{
				std::lock_guard<std::mutex> lock(m_pool_mutex);
				clear();
			}
			try_connect();
		}
	}

	Database* create_database()
	{
		Database* db=new_database();
		if(db) return db;

		{
			std::lock_guard<std::mutex> lock(m_pool_mutex);
			clear();
		}
		try_connect();
		return NULL;
	}

	Database* popup()
	{
		Database* db=NULL;
		std::lock_guard<std::mutex> lock(m_pool_mutex);
		if(!m_databases.empty())
		{
			db=m_databases.back();
			m_databases.pop_back();
		}
		return db;
	}

	void try_connect()
	{
		if(m_trying_connection)
			return;

		m_trying_connection=true;
		
		try
		{
			m_background_thread=std::thread(&database_pool<Database>::background_connect, this);
		}
		catch (std::system_error&)
		{
			m_trying_connection=false;
		}
	}

	void background_connect()
	{
		Database* db=NULL;
		int interval=1;
		while(db==NULL && m_stop_thread==false)
		{
			db=create_database();
			if(db==NULL)
			{
				std::this_thread::sleep_for(std::chrono::seconds(interval));
				if(interval<60) interval<<=1;
			}
		}
		if(db)
		{
			recovery(db);
		}
		m_background_thread.detach();
		m_trying_connection=false;
	}

	void clear()
	{
		std::for_each(m_databases.begin(), m_databases.end(), std::default_delete<Database>());
		m_databases.clear();
	}
};

template<typename T, typename EventLoop, typename Connection>
class async_pool
{
public:
	typedef Connection value_type;
	typedef std::shared_ptr<Connection> pointer;

	async_pool(EventLoop& ev)
		: m_ev(ev), m_trying_connecting(false)
	{
	}

	virtual ~async_pool()
	{
		clear();
	}

	/*
		Handler defines as:
		void handler(const pointer& ptr);
	*/
	template<typename Handler>
	void get(Handler&& handler, EventLoop* ev=nullptr)
	{
		Connection* db = popup();
		if(ev==nullptr) ev=&m_ev;
		
		if(db)
		{
			db->bind(*ev);
			handler(typename Connection::exception_type(), wrap(db));
		}
		else if (m_trying_connecting == false)
		{
			create_connection(ev, [this, handler](const typename Connection::exception_type& e,  Connection* db) {
				handler(e, wrap(db));
			});
		}
		else
		{
			handler(typename Connection::exception_type(), nullptr);
		}
	}

	void test_alive()
	{
		if (m_connections.empty())
			return;
		std::unique_lock<std::mutex> lock(m_pool_mutex);
		auto it = m_connections.begin();
		while (it != m_connections.end())
		{
			Connection* db = *it;
			db->is_alive([this, db](const typename Connection::exception_type& e) {
				if (e)
				{
					std::unique_lock<std::mutex> lock(m_pool_mutex);
					auto it = std::find(m_connections.begin(), m_connections.end(), db);
					delete db;
					m_connections.erase(it);
					if (m_connections.empty())
						try_connect();
				}
			});
			++it;
		}
	}

private:
	EventLoop& m_ev;
	std::vector<Connection*> m_connections;
	std::recursive_mutex m_pool_mutex;
	std::atomic<bool> m_trying_connecting;

	void recovery(Connection* db)
	{
		if (db == NULL) return;
		db->is_alive([this, db](const typename Connection::exception_type& e) {
			if (e)
			{
				{
					std::lock_guard<std::recursive_mutex> lock(m_pool_mutex);
					clear();
				}
				try_connect();
			}
			else
			{
				if(!db->unbind())
					throw std::runtime_error("destroy a busysing connection.");
				std::lock_guard<std::recursive_mutex> lock(m_pool_mutex);
				m_connections.push_back(db);
			}
		});
	}

	template<typename Handler>
	void create_connection(EventLoop* ev, Handler&& handler)
	{
		T* pThis = static_cast<T*>(this);
		pThis->new_connection(*ev, [this, handler](const typename Connection::exception_type& e, Connection* db) {
			handler(e, db);
			if (!db)
			{
				std::lock_guard<std::recursive_mutex> lock(m_pool_mutex);
				clear();

				timeval tv = { 1,  0};
				m_ev.set_timeout(tv, [this]() {
					try_connect();
				});
			}
		});
	}

	Connection* popup()
	{
		Connection* db = nullptr;
		std::lock_guard<std::recursive_mutex> lock(m_pool_mutex);
		if (!m_connections.empty())
		{
			db = m_connections.back();
			m_connections.pop_back();
		}
		return db;
	}

	void try_connect()
	{
		if (m_trying_connecting)
			return;

		m_trying_connecting = true;
		create_connection(&m_ev, [this](const typename Connection::exception_type& e, Connection* db) {
			if (db)
			{
				std::lock_guard<std::recursive_mutex> lock(m_pool_mutex);
				m_connections.push_back(db);
			}
			else
			{
				m_trying_connecting = false;
			}
		});
	}

	void clear()
	{
		std::for_each(m_connections.begin(), m_connections.end(), std::default_delete<Connection>());
		m_connections.clear();
	}

	pointer wrap(Connection* db)
	{
		if (db)
		{
			return pointer(db, [this](Connection* db) {
				recovery(db);
			});
		}
		else return nullptr;
	}
};

}

#endif //_QTL_DATABASE_POOL_H_