Changeset - be3af42a21a7
[Not reviewed]
0 2 0
Vitaly Takmazov - 7 years ago 2018-09-21 22:59:27
vitalyster@gmail.com
MySQLBackend: disable autoreconnect, control CR_SERVER_LOST manually

* correctly recreate prepared statements
* do not close connection while reconnecting
* signed/unsigned comparison fix
2 files changed with 6 insertions and 8 deletions:
0 comments (0 inline, 0 general)
include/transport/MySQLBackend.h
Show inline comments
 
@@ -120,25 +120,25 @@ class MySQLBackend : public StorageBackend
 

	
 
				// Pulls fetched data by previous execute(); call.
 
				template <typename T>
 
				Statement& operator >> (T& t);
 
				
 
				Statement& operator >> (std::string& t);
 
			private:
 
				MYSQL_STMT *m_stmt;
 
				MYSQL *m_conn;
 
				std::vector<MYSQL_BIND> m_params;
 
				std::vector<MYSQL_BIND> m_results;
 
				int m_error;
 
				unsigned m_resultOffset;
 
				int m_resultOffset;
 
				unsigned m_offset;
 
				std::string m_string;
 
		};
 

	
 
		MYSQL m_conn;
 
		Config *m_config;
 
		std::string m_prefix;
 

	
 
		// statements
 
// 		MYSQL_STMT *m_setUser;
 
		Statement *m_setUser;
 
		Statement *m_getUser;
libtransport/MySQLBackend.cpp
Show inline comments
 
@@ -21,47 +21,47 @@
 
#ifdef WITH_MYSQL
 

	
 
#include "transport/MySQLBackend.h"
 
#include "transport/Util.h"
 
#include "transport/Logging.h"
 
#include <boost/bind.hpp>
 

	
 
#define EXEC(STMT, METHOD) \
 
	{\
 
	int ret = STMT->execute(); \
 
	if (ret == 0) \
 
		exec_ok = true; \
 
	else if (ret == CR_SERVER_LOST) { \
 
	else if (ret == CR_SERVER_LOST || ret == CR_SERVER_GONE_ERROR) { \
 
		LOG4CXX_INFO(logger, "MySQL connection lost. Reconnecting...");\
 
		disconnect(); \
 
		connect(); \
 
		return METHOD; \
 
	} \
 
	else \
 
		exec_ok = false; \
 
	}
 

	
 
namespace Transport {
 

	
 
DEFINE_LOGGER(logger, "MySQLBackend");
 
static bool exec_ok;
 

	
 
MySQLBackend::Statement::Statement(MYSQL *conn, const std::string &format, const std::string &statement) {
 
	m_resultOffset = -1;
 
	m_conn = conn;
 
	m_offset = 0;
 
	m_string = statement;
 
	m_stmt = mysql_stmt_init(conn);
 
	if (mysql_stmt_prepare(m_stmt, statement.c_str(), statement.size())) {
 
		LOG4CXX_ERROR(logger, statement << " " << mysql_error(conn));
 
		LOG4CXX_ERROR(logger, statement << " " << mysql_stmt_error(m_stmt));
 
		return;
 
	}
 

	
 
	for (unsigned i = 0; i < format.length() && m_resultOffset == -1; i++) {
 
		switch (format.at(i)) {
 
			case 's':
 
				m_params.resize(m_params.size() + 1);
 
				memset(&m_params.back(), 0, sizeof(MYSQL_BIND));
 

	
 
				m_params.back().buffer_type= MYSQL_TYPE_STRING;
 
				m_params.back().buffer= (char *) malloc(sizeof(char) * 4096);
 
				m_params.back().buffer_length= 4096;
 
@@ -117,32 +117,32 @@ MySQLBackend::Statement::Statement(MYSQL *conn, const std::string &format, const
 
				m_results.resize(m_results.size() + 1);
 
				memset(&m_results.back(), 0, sizeof(MYSQL_BIND));
 

	
 
				m_results.back().buffer_type= MYSQL_TYPE_TINY;
 
				m_results.back().buffer= (int *) malloc(sizeof(int));
 
				m_results.back().is_null= 0;
 
				m_results.back().length= (unsigned long *) malloc(sizeof(unsigned long));
 
				break;
 
		}
 
	}
 

	
 
	if (mysql_stmt_bind_param(m_stmt, &m_params.front())) {
 
		LOG4CXX_ERROR(logger, statement << " " << mysql_error(conn));
 
		LOG4CXX_ERROR(logger, statement << " " << mysql_stmt_error(m_stmt));
 
	}
 

	
 
	if (m_resultOffset < 0)
 
		m_resultOffset = format.size();
 
	else {
 
		if (mysql_stmt_bind_result(m_stmt, &m_results.front())) {
 
			LOG4CXX_ERROR(logger, statement << " " << mysql_error(conn));
 
			LOG4CXX_ERROR(logger, statement << " " << mysql_stmt_error(m_stmt));
 
		}
 
	}
 
	m_resultOffset = 0;
 
}
 

	
 
MySQLBackend::Statement::~Statement() {
 
	for (unsigned i = 0; i < m_params.size(); i++) {
 
		free(m_params[i].buffer);
 
		free(m_params[i].length);
 
	}
 
	for (unsigned i = 0; i < m_results.size(); i++) {
 
		free(m_results[i].buffer);
 
@@ -218,55 +218,53 @@ MySQLBackend::Statement& MySQLBackend::Statement::operator >> (std::string& t) {
 
		t = (char *) m_results[m_resultOffset].buffer;
 
	}
 

	
 
	if (++m_resultOffset == m_results.size())
 
		m_resultOffset = 0;
 
	return *this;
 
}
 

	
 
MySQLBackend::MySQLBackend(Config *config) {
 
	m_config = config;
 
	m_prefix = CONFIG_STRING(m_config, "database.prefix");
 
	mysql_init(&m_conn);
 
	my_bool my_true = 1;
 
	mysql_options(&m_conn, MYSQL_OPT_RECONNECT, &my_true);
 
}
 

	
 
MySQLBackend::~MySQLBackend(){
 
	disconnect();
 
	mysql_close(&m_conn);
 
}
 

	
 
void MySQLBackend::disconnect() {
 
	LOG4CXX_INFO(logger, "Disconnecting");
 
	delete m_setUser;
 
	delete m_getUser;
 
	delete m_removeUser;
 
	delete m_removeUserBuddies;
 
	delete m_removeUserSettings;
 
	delete m_removeUserBuddiesSettings;
 
	delete m_addBuddy;
 
	delete m_removeBuddy;
 
	delete m_removeBuddySettings;
 
	delete m_updateBuddy;
 
	delete m_getBuddies;
 
	delete m_getBuddiesSettings;
 
	delete m_getUserSetting;
 
	delete m_setUserSetting;
 
	delete m_updateUserSetting;
 
	delete m_updateBuddySetting;
 
	delete m_getBuddySetting;
 
	delete m_setUserOnline;
 
	delete m_getOnlineUsers;
 
	delete m_getUsers;
 
	mysql_close(&m_conn);
 
}
 

	
 
bool MySQLBackend::connect() {
 
	LOG4CXX_INFO(logger, "Connecting MySQL server " << CONFIG_STRING(m_config, "database.server") << ", user " <<
 
		CONFIG_STRING(m_config, "database.user") << ", database " << CONFIG_STRING(m_config, "database.database") <<
 
		", port " << CONFIG_INT(m_config, "database.port")
 
	);
 

	
 
	if (!mysql_real_connect(&m_conn, CONFIG_STRING(m_config, "database.server").c_str(),
 
					   CONFIG_STRING(m_config, "database.user").c_str(),
 
					   CONFIG_STRING(m_config, "database.password").c_str(),
 
					   CONFIG_STRING(m_config, "database.database").c_str(),
0 comments (0 inline, 0 general)