aherman
/
proxysql
mirror of https://github.com/sysown/proxysql
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add initial POC for PostgreSQL monitoring support

Browse Source
v3.0-postgres_monitor_poc
Javier Jaramago Fernández 1 year ago
parent e4be6c2fbe
commit 705f50e0f9
12 changed files with 1926 additions and 28 deletions
Show Stats Download Patch File Download Diff File

2
include/PgSQL_HostGroups_Manager.h
Unescape View File

@ -585,7 +585,7 @@ class PgSQL_HostGroups_Manager : public Base_HostGroups_Manager<PgSQL_HGC> {
/**
* @brief Mutex used to guard 'pgsql_servers_to_monitor' resulset.
*/
std::mutex pgsql_servers_to_monitor_mutex;
std::mutex pgsql_servers_to_monitor_mutex {};
/**
* @brief Resulset containing the latest 'pgsql_servers' present in 'mydb'.
* @details This resulset should be updated via 'update_table_pgsql_servers_for_monitor' each time actions

71
include/PgSQL_Monitor.hpp
Unescape View File

@ -0,0 +1,71 @@
#ifndef __PGSQL_MONITOR_H
#define __PGSQL_MONITOR_H
#include "libpq-fe.h"
#include "sqlite3db.h"
#include "proxysql_structs.h"
#include <cassert>
#include <mutex>
#include <vector>
#define MONITOR_SQLITE_TABLE_PGSQL_SERVER_CONNECT_LOG "CREATE TABLE pgsql_server_connect_log (hostname VARCHAR NOT NULL , port INT NOT NULL DEFAULT 3306 , time_start_us INT NOT NULL DEFAULT 0 , connect_success_time_us INT DEFAULT 0 , connect_error VARCHAR , PRIMARY KEY (hostname, port, time_start_us))"
#define MONITOR_SQLITE_TABLE_PGSQL_SERVER_PING_LOG "CREATE TABLE pgsql_server_ping_log ( hostname VARCHAR NOT NULL , port INT NOT NULL DEFAULT 3306 , time_start_us INT NOT NULL DEFAULT 0 , ping_success_time_us INT DEFAULT 0 , ping_error VARCHAR , PRIMARY KEY (hostname, port, time_start_us))"
#define MONITOR_SQLITE_TABLE_PGSQL_SERVERS "CREATE TABLE pgsql_servers (hostname VARCHAR NOT NULL , port INT NOT NULL DEFAULT 3306 , status INT CHECK (status IN (0, 1, 2, 3, 4)) NOT NULL DEFAULT 0 , use_ssl INT CHECK (use_ssl IN(0,1)) NOT NULL DEFAULT 0 , PRIMARY KEY (hostname, port) )"
#define MONITOR_SQLITE_TABLE_PROXYSQL_SERVERS "CREATE TABLE proxysql_servers (hostname VARCHAR NOT NULL , port INT NOT NULL DEFAULT 6032 , weight INT CHECK (weight >= 0) NOT NULL DEFAULT 0 , comment VARCHAR NOT NULL DEFAULT '' , PRIMARY KEY (hostname, port) )"
struct PgSQL_Monitor {
// @brief Flags if monitoring threads should be shutdown.
bool shutdown = false;
// @brief Mutex to hold to update `monitor_internal.pgsql_servers`
std::mutex pgsql_srvs_mutex {};
// @brief Mutex to hold to update/read `pgsql_servers` to monitor
std::mutex pgsql_srvs_to_monitor_mutex {};
// @brief Used to access monitor database
SQLite3DB monitordb {};
// @brief Used to access internal monitor database
SQLite3DB monitor_internal_db {};
// Internal counters for metrics
///////////////////////////////////////////////////////////////////////////
uint64_t connect_check_ERR { 0 };
uint64_t connect_check_OK { 0 };
uint64_t ping_check_ERR { 0 };
uint64_t ping_check_OK { 0 };
///////////////////////////////////////////////////////////////////////////
std::vector<table_def_t> tables_defs_monitor {
{
const_cast<char*>("pgsql_server_connect_log"),
const_cast<char*>(MONITOR_SQLITE_TABLE_PGSQL_SERVER_CONNECT_LOG)
},
{
const_cast<char*>("pgsql_server_ping_log"),
const_cast<char*>(MONITOR_SQLITE_TABLE_PGSQL_SERVER_PING_LOG)
}
};
std::vector<table_def_t> tables_defs_monitor_internal {
{
const_cast<char*>("pgsql_servers"),
const_cast<char*>(MONITOR_SQLITE_TABLE_PGSQL_SERVERS)
}
};
PgSQL_Monitor();
};
struct pgsql_conn_t {
PGconn* conn { nullptr };
int fd { 0 };
uint64_t last_used { 0 };
ASYNC_ST state { ASYNC_ST::ASYNC_CONNECT_FAILED };
mf_unique_ptr<char> err {};
};
void* PgSQL_monitor_scheduler_thread();
#endif

6
include/PgSQL_Thread.h
Unescape View File

@ -6,7 +6,6 @@
#include "proxysql.h"
#include "Base_Thread.h"
#include "cpp.h"
#include "ProxySQL_Poll.h"
#include "PgSQL_Variables.h"
#ifdef IDLE_THREADS
@ -825,6 +824,7 @@ public:
//! Read only check timeout. Unit: 'ms'.
int monitor_replication_lag_timeout;
int monitor_replication_lag_count;
/* TODO: Remove
int monitor_groupreplication_healthcheck_interval;
int monitor_groupreplication_healthcheck_timeout;
int monitor_groupreplication_healthcheck_max_timeout_count;
@ -836,9 +836,13 @@ public:
int monitor_query_interval;
int monitor_query_timeout;
int monitor_slave_lag_when_null;
*/
int monitor_threads;
/* TODO: Remove
int monitor_threads_min;
int monitor_threads_max;
int monitor_threads_queue_maxsize;
*/
int monitor_local_dns_cache_ttl;
int monitor_local_dns_cache_refresh_interval;
int monitor_local_dns_resolver_queue_maxsize;

1
include/PgSQL_Variables.h
Unescape View File

@ -2,7 +2,6 @@
#define PGSQL_VARIABLES_H
#include "proxysql.h"
#include "cpp.h"
#include <cstdint>
#include <vector>

1
include/cpp.h
Unescape View File

@ -15,6 +15,7 @@
#include "sqlite3db.h"
//#include "StatCounters.h"
#include "MySQL_Monitor.hpp"
#include "PgSQL_Monitor.hpp"
//#include "MySQL_Protocol.h"
//#include "MySQL_Authentication.hpp"
//#include "MySQL_LDAP_Authentication.hpp"

31
include/proxysql_structs.h
Unescape View File

@ -647,6 +647,7 @@ enum PROXYSQL_MYSQL_ERR {
ER_PROXYSQL_AWS_HEALTH_CHECK_CONN_TIMEOUT = 9017,
ER_PROXYSQL_AWS_HEALTH_CHECK_TIMEOUT = 9018,
ER_PROXYSQL_SRV_NULL_REPLICATION_LAG = 9019,
ER_PROXYSQL_CONNECT_TIMEOUT = 9020,
};
enum proxysql_session_type {
@ -1079,6 +1080,21 @@ __thread char* pgsql_thread___firewall_whitelist_errormsg;
__thread bool pgsql_thread___firewall_whitelist_enabled;
__thread int pgsql_thread___query_processor_iterations;
__thread int pgsql_thread___query_processor_regex;
__thread bool pgsql_thread___monitor_enabled;
__thread int pgsql_thread___monitor_history;
__thread int pgsql_thread___monitor_connect_interval;
__thread int pgsql_thread___monitor_connect_timeout;
__thread int pgsql_thread___monitor_ping_interval;
__thread int pgsql_thread___monitor_ping_max_failures;
__thread int pgsql_thread___monitor_ping_timeout;
__thread int pgsql_thread___monitor_read_only_interval;
__thread int pgsql_thread___monitor_read_only_timeout;
__thread int pgsql_thread___monitor_read_only_max_timeout_count;
__thread int pgsql_thread___monitor_threads;
__thread char* pgsql_thread___monitor_username;
__thread char* pgsql_thread___monitor_password;
//---------------------------
__thread char *mysql_thread___default_schema;
@ -1351,6 +1367,21 @@ extern __thread char* pgsql_thread___firewall_whitelist_errormsg;
extern __thread bool pgsql_thread___firewall_whitelist_enabled;
extern __thread int pgsql_thread___query_processor_iterations;
extern __thread int pgsql_thread___query_processor_regex;
extern __thread bool pgsql_thread___monitor_enabled;
extern __thread int pgsql_thread___monitor_history;
extern __thread int pgsql_thread___monitor_connect_interval;
extern __thread int pgsql_thread___monitor_connect_timeout;
extern __thread int pgsql_thread___monitor_ping_interval;
extern __thread int pgsql_thread___monitor_ping_max_failures;
extern __thread int pgsql_thread___monitor_ping_timeout;
extern __thread int pgsql_thread___monitor_read_only_interval;
extern __thread int pgsql_thread___monitor_read_only_timeout;
extern __thread int pgsql_thread___monitor_read_only_max_timeout_count;
extern __thread int pgsql_thread___monitor_threads;
extern __thread char* pgsql_thread___monitor_username;
extern __thread char* pgsql_thread___monitor_password;
//---------------------------
extern __thread char *mysql_thread___default_schema;

1
lib/Base_HostGroups_Manager.cpp
Unescape View File

@ -53,6 +53,7 @@ template void Base_HostGroups_Manager<PgSQL_HGC>::wrlock();
template void Base_HostGroups_Manager<PgSQL_HGC>::wrunlock();
template SQLite3_result * Base_HostGroups_Manager<MyHGC>::execute_query(char*, char**);
template SQLite3_result * Base_HostGroups_Manager<PgSQL_HGC>::execute_query(char*, char**);
#if 0
#define SAFE_SQLITE3_STEP(_stmt) do {\

2
lib/Makefile
Unescape View File

@ -147,7 +147,7 @@ _OBJ_CXX := ProxySQL_GloVars.oo network.oo debug.oo configfile.oo Query_Cache.oo
Base_Session.oo Base_Thread.oo \
proxy_protocol_info.oo \
proxysql_find_charset.oo ProxySQL_Poll.oo \
PgSQL_Protocol.oo PgSQL_Thread.oo PgSQL_Data_Stream.oo PgSQL_Session.oo PgSQL_Variables.oo PgSQL_HostGroups_Manager.oo PgSQL_Connection.oo PgSQL_Backend.oo PgSQL_Logger.oo PgSQL_Authentication.oo PgSQL_Error_Helper.oo
PgSQL_Protocol.oo PgSQL_Thread.oo PgSQL_Data_Stream.oo PgSQL_Session.oo PgSQL_Variables.oo PgSQL_HostGroups_Manager.oo PgSQL_Connection.oo PgSQL_Backend.oo PgSQL_Logger.oo PgSQL_Authentication.oo PgSQL_Error_Helper.oo PgSQL_Monitor.oo
OBJ_CXX := $(patsubst %,$(ODIR)/%,$(_OBJ_CXX))
HEADERS := ../include/*.h ../include/*.hpp

1735
lib/PgSQL_Monitor.cpp
View File

File diff suppressed because it is too large Load Diff

72
lib/PgSQL_Thread.cpp
Unescape View File

@ -45,6 +45,7 @@ static PgSQL_Session* sess_stopat;
extern PgSQL_Query_Processor* GloPgQPro;
extern PgSQL_Threads_Handler* GloPTH;
extern MySQL_Monitor* GloMyMon;
extern PgSQL_Monitor* GloPgMon;
extern PgSQL_Logger* GloPgSQL_Logger;
typedef struct mythr_st_vars {
@ -314,6 +315,7 @@ static char* pgsql_thread_variables_names[] = {
(char*)"monitor_ping_interval",
(char*)"monitor_ping_max_failures",
(char*)"monitor_ping_timeout",
/*
(char*)"monitor_aws_rds_topology_discovery_interval",
(char*)"monitor_read_only_interval",
(char*)"monitor_read_only_timeout",
@ -330,12 +332,17 @@ static char* pgsql_thread_variables_names[] = {
(char*)"monitor_galera_healthcheck_interval",
(char*)"monitor_galera_healthcheck_timeout",
(char*)"monitor_galera_healthcheck_max_timeout_count",
*/
(char*)"monitor_username",
(char*)"monitor_password",
/*
(char*)"monitor_replication_lag_use_percona_heartbeat",
(char*)"monitor_query_interval",
(char*)"monitor_query_timeout",
(char*)"monitor_slave_lag_when_null",
*/
(char*)"monitor_threads",
/*
(char*)"monitor_threads_min",
(char*)"monitor_threads_max",
(char*)"monitor_threads_queue_maxsize",
@ -344,6 +351,7 @@ static char* pgsql_thread_variables_names[] = {
(char*)"monitor_local_dns_resolver_queue_maxsize",
(char*)"monitor_wait_timeout",
(char*)"monitor_writer_is_also_reader",
*/
(char*)"max_allowed_packet",
(char*)"tcp_keepalive_time",
(char*)"use_tcp_keepalive",
@ -936,6 +944,7 @@ PgSQL_Threads_Handler::PgSQL_Threads_Handler() {
variables.monitor_replication_lag_interval = 10000;
variables.monitor_replication_lag_timeout = 1000;
variables.monitor_replication_lag_count = 1;
/* TODO: Remove
variables.monitor_groupreplication_healthcheck_interval = 5000;
variables.monitor_groupreplication_healthcheck_timeout = 800;
variables.monitor_groupreplication_healthcheck_max_timeout_count = 3;
@ -950,12 +959,16 @@ PgSQL_Threads_Handler::PgSQL_Threads_Handler() {
variables.monitor_threads_min = 8;
variables.monitor_threads_max = 128;
variables.monitor_threads_queue_maxsize = 128;
*/
variables.monitor_threads = 2;
variables.monitor_local_dns_cache_ttl = 300000;
variables.monitor_local_dns_cache_refresh_interval = 60000;
variables.monitor_local_dns_resolver_queue_maxsize = 128;
variables.monitor_username = strdup((char*)"monitor");
variables.monitor_password = strdup((char*)"monitor");
/* TODO: Remove
variables.monitor_replication_lag_use_percona_heartbeat = strdup((char*)"");
*/
variables.monitor_wait_timeout = true;
variables.monitor_writer_is_also_reader = true;
variables.max_allowed_packet = 64 * 1024 * 1024;
@ -1168,7 +1181,9 @@ char* PgSQL_Threads_Handler::get_variable_string(char* name) {
if (!strncmp(name, "monitor_", 8)) {
if (!strcmp(name, "monitor_username")) return strdup(variables.monitor_username);
if (!strcmp(name, "monitor_password")) return strdup(variables.monitor_password);
/*
if (!strcmp(name, "monitor_replication_lag_use_percona_heartbeat")) return strdup(variables.monitor_replication_lag_use_percona_heartbeat);
*/
}
if (!strncmp(name, "ssl_", 4)) {
if (!strcmp(name, "ssl_p2s_ca")) {
@ -1489,7 +1504,9 @@ char* PgSQL_Threads_Handler::get_variable(char* name) { // this is the public fu
if (!strncasecmp(name, "monitor_", 8)) {
if (!strcasecmp(name, "monitor_username")) return strdup(variables.monitor_username);
if (!strcasecmp(name, "monitor_password")) return strdup(variables.monitor_password);
/*
if (!strcasecmp(name, "monitor_replication_lag_use_percona_heartbeat")) return strdup(variables.monitor_replication_lag_use_percona_heartbeat);
*/
}
if (!strcasecmp(name, "threads")) {
sprintf(intbuf, "%d", (num_threads ? num_threads : DEFAULT_NUM_THREADS));
@ -2068,11 +2085,13 @@ char** PgSQL_Threads_Handler::get_variables_list() {
VariablesPointers_int["monitor_ping_timeout"] = make_tuple(&variables.monitor_ping_timeout, 100, 600 * 1000, false);
VariablesPointers_int["monitor_ping_max_failures"] = make_tuple(&variables.monitor_ping_max_failures, 1, 1000 * 1000, false);
/*
VariablesPointers_int["monitor_aws_rds_topology_discovery_interval"] = make_tuple(&variables.monitor_aws_rds_topology_discovery_interval, 1, 100000, false);
*/
VariablesPointers_int["monitor_read_only_interval"] = make_tuple(&variables.monitor_read_only_interval, 100, 7 * 24 * 3600 * 1000, false);
VariablesPointers_int["monitor_read_only_timeout"] = make_tuple(&variables.monitor_read_only_timeout, 100, 600 * 1000, false);
VariablesPointers_int["monitor_read_only_max_timeout_count"] = make_tuple(&variables.monitor_read_only_max_timeout_count, 1, 1000 * 1000, false);
/*
VariablesPointers_int["monitor_replication_lag_interval"] = make_tuple(&variables.monitor_replication_lag_interval, 100, 7 * 24 * 3600 * 1000, false);
VariablesPointers_int["monitor_replication_lag_timeout"] = make_tuple(&variables.monitor_replication_lag_timeout, 100, 600 * 1000, false);
VariablesPointers_int["monitor_replication_lag_count"] = make_tuple(&variables.monitor_replication_lag_count, 1, 10, false);
@ -2089,13 +2108,17 @@ char** PgSQL_Threads_Handler::get_variables_list() {
VariablesPointers_int["monitor_query_interval"] = make_tuple(&variables.monitor_query_interval, 100, 7 * 24 * 3600 * 1000, false);
VariablesPointers_int["monitor_query_timeout"] = make_tuple(&variables.monitor_query_timeout, 100, 600 * 1000, false);
*/
VariablesPointers_int["monitor_threads"] = make_tuple(&variables.monitor_threads, 2, 256, false);
/*
VariablesPointers_int["monitor_threads_min"] = make_tuple(&variables.monitor_threads_min, 2, 256, false);
VariablesPointers_int["monitor_threads_max"] = make_tuple(&variables.monitor_threads_max, 4, 1024, false);
VariablesPointers_int["monitor_slave_lag_when_null"] = make_tuple(&variables.monitor_slave_lag_when_null, 0, 604800, false);
VariablesPointers_int["monitor_threads_queue_maxsize"] = make_tuple(&variables.monitor_threads_queue_maxsize, 16, 1024, false);
VariablesPointers_int["monitor_threads_queue_maxsize"] = make_tuple(&variables.monitor_threads_queue_maxsize, 16, 1024, false);
*/
VariablesPointers_int["monitor_local_dns_cache_ttl"] = make_tuple(&variables.monitor_local_dns_cache_ttl, 0, 7 * 24 * 3600 * 1000, false);
VariablesPointers_int["monitor_local_dns_cache_refresh_interval"] = make_tuple(&variables.monitor_local_dns_cache_refresh_interval, 0, 7 * 24 * 3600 * 1000, false);
VariablesPointers_int["monitor_local_dns_resolver_queue_maxsize"] = make_tuple(&variables.monitor_local_dns_resolver_queue_maxsize, 16, 1024, false);
@ -3783,16 +3806,25 @@ void PgSQL_Thread::refresh_variables() {
mysql_thread___monitor_wait_timeout = (bool)GloPTH->get_variable_int((char*)"monitor_wait_timeout");
mysql_thread___monitor_writer_is_also_reader = (bool)GloPTH->get_variable_int((char*)"monitor_writer_is_also_reader");
mysql_thread___monitor_enabled = (bool)GloPTH->get_variable_int((char*)"monitor_enabled");
mysql_thread___monitor_history = GloPTH->get_variable_int((char*)"monitor_history");
mysql_thread___monitor_connect_interval = GloPTH->get_variable_int((char*)"monitor_connect_interval");
mysql_thread___monitor_connect_timeout = GloPTH->get_variable_int((char*)"monitor_connect_timeout");
mysql_thread___monitor_ping_interval = GloPTH->get_variable_int((char*)"monitor_ping_interval");
mysql_thread___monitor_ping_max_failures = GloPTH->get_variable_int((char*)"monitor_ping_max_failures");
mysql_thread___monitor_ping_timeout = GloPTH->get_variable_int((char*)"monitor_ping_timeout");
*/
pgsql_thread___monitor_enabled = (bool)GloPTH->get_variable_int((char*)"monitor_enabled");
pgsql_thread___monitor_history = GloPTH->get_variable_int((char*)"monitor_history");
pgsql_thread___monitor_connect_interval = GloPTH->get_variable_int((char*)"monitor_connect_interval");
pgsql_thread___monitor_connect_timeout = GloPTH->get_variable_int((char*)"monitor_connect_timeout");
pgsql_thread___monitor_ping_interval = GloPTH->get_variable_int((char*)"monitor_ping_interval");
pgsql_thread___monitor_ping_max_failures = GloPTH->get_variable_int((char*)"monitor_ping_max_failures");
pgsql_thread___monitor_ping_timeout = GloPTH->get_variable_int((char*)"monitor_ping_timeout");
pgsql_thread___monitor_read_only_interval = GloPTH->get_variable_int((char*)"monitor_read_only_interval");
pgsql_thread___monitor_read_only_timeout = GloPTH->get_variable_int((char*)"monitor_read_only_timeout");
pgsql_thread___monitor_threads = GloPTH->get_variable_int((char*)"monitor_threads");
if (pgsql_thread___monitor_username) free(pgsql_thread___monitor_username);
pgsql_thread___monitor_username = GloPTH->get_variable_string((char*)"monitor_username");
if (pgsql_thread___monitor_password) free(pgsql_thread___monitor_password);
pgsql_thread___monitor_password = GloPTH->get_variable_string((char*)"monitor_password");
/*
mysql_thread___monitor_aws_rds_topology_discovery_interval = GloPTH->get_variable_int((char *)"monitor_aws_rds_topology_discovery_interval");
mysql_thread___monitor_read_only_interval = GloPTH->get_variable_int((char*)"monitor_read_only_interval");
mysql_thread___monitor_read_only_timeout = GloPTH->get_variable_int((char*)"monitor_read_only_timeout");
mysql_thread___monitor_read_only_max_timeout_count = GloPTH->get_variable_int((char*)"monitor_read_only_max_timeout_count");
mysql_thread___monitor_replication_lag_group_by_host = (bool)GloPTH->get_variable_int((char*)"monitor_replication_lag_group_by_host");
mysql_thread___monitor_replication_lag_interval = GloPTH->get_variable_int((char*)"monitor_replication_lag_interval");
@ -4377,30 +4409,32 @@ SQLite3_result* PgSQL_Threads_Handler::SQL3_GlobalStatus(bool _memory) {
pta[1] = buf;
result->add_row(pta);
}
*/
{
pta[0] = (char*)"MySQL_Monitor_connect_check_OK";
sprintf(buf, "%llu", GloMyMon->connect_check_OK);
pta[0] = (char*)"PgSQL_Monitor_connect_check_OK";
sprintf(buf, "%lu", GloPgMon->connect_check_OK);
pta[1] = buf;
result->add_row(pta);
}
{
pta[0] = (char*)"MySQL_Monitor_connect_check_ERR";
sprintf(buf, "%llu", GloMyMon->connect_check_ERR);
pta[0] = (char*)"PgSQL_Monitor_connect_check_ERR";
sprintf(buf, "%lu", GloPgMon->connect_check_ERR);
pta[1] = buf;
result->add_row(pta);
}
{
pta[0] = (char*)"MySQL_Monitor_ping_check_OK";
sprintf(buf, "%llu", GloMyMon->ping_check_OK);
pta[0] = (char*)"PgSQL_Monitor_ping_check_OK";
sprintf(buf, "%lu", GloPgMon->ping_check_OK);
pta[1] = buf;
result->add_row(pta);
}
{
pta[0] = (char*)"MySQL_Monitor_ping_check_ERR";
sprintf(buf, "%llu", GloMyMon->ping_check_ERR);
pta[0] = (char*)"PgSQL_Monitor_ping_check_ERR";
sprintf(buf, "%lu", GloPgMon->ping_check_ERR);
pta[1] = buf;
result->add_row(pta);
}
/*
{
pta[0] = (char*)"MySQL_Monitor_read_only_check_OK";
sprintf(buf, "%llu", GloMyMon->read_only_check_OK);

2
lib/ProxySQL_Poll.cpp
Unescape View File

@ -175,4 +175,4 @@ int ProxySQL_Poll<T>::find_index(int fd) {
}
template class ProxySQL_Poll<PgSQL_Data_Stream>;
template class ProxySQL_Poll<MySQL_Data_Stream>;
template class ProxySQL_Poll<MySQL_Data_Stream>;

30
src/main.cpp
Unescape View File

@ -34,6 +34,7 @@ using json = nlohmann::json;
#include "proxysql_restapi.h"
#include "Web_Interface.hpp"
#include "proxysql_utils.h"
#include "PgSQL_Monitor.hpp"
#include "libdaemon/dfork.h"
#include "libdaemon/dsignal.h"
@ -82,6 +83,7 @@ void * __mysql_ldap_auth;
volatile create_Web_Interface_t * create_Web_Interface = NULL;
void * __web_interface;
std::thread* pgsql_monitor_thread = nullptr;
extern int ProxySQL_create_or_load_TLS(bool bootstrap, std::string& msg);
@ -458,6 +460,7 @@ Web_Interface *GloWebInterface;
MySQL_STMT_Manager_v14 *GloMyStmt;
MySQL_Monitor *GloMyMon;
PgSQL_Monitor *GloPgMon;
std::thread *MyMon_thread = NULL;
MySQL_Logger *GloMyLogger;
@ -1007,7 +1010,9 @@ void ProxySQL_Main_join_all_threads() {
if (GloMyMon) {
GloMyMon->shutdown=true;
}
if (GloPgMon) {
GloPgMon->shutdown=true;
}
// join GloMyMon thread
if (GloMyMon && MyMon_thread) {
cpu_timer t;
@ -1018,7 +1023,15 @@ void ProxySQL_Main_join_all_threads() {
std::cerr << "GloMyMon joined in ";
#endif
}
if (GloPgMon && pgsql_monitor_thread) {
cpu_timer t;
pgsql_monitor_thread->join();
delete pgsql_monitor_thread;
pgsql_monitor_thread = NULL;
#ifdef DEBUG
std::cerr << "GloPgMon joined in ";
#endif
}
// join GloQC thread
if (GloQC) {
cpu_timer t;
@ -1041,7 +1054,14 @@ void ProxySQL_Main_shutdown_all_modules() {
std::cerr << "GloMyMon shutdown in ";
#endif
}
if (GloPgMon) {
cpu_timer t;
delete GloPgMon;
GloPgMon=NULL;
#ifdef DEBUG
std::cerr << "GloPgMon shutdown in ";
#endif
}
if (GloQC) {
cpu_timer t;
delete GloQC;
@ -1302,7 +1322,6 @@ void ProxySQL_Main_init_phase2___not_started(const bootstrap_info_t& boostrap_in
}
}
void ProxySQL_Main_init_phase3___start_all() {
{
@ -1323,6 +1342,7 @@ void ProxySQL_Main_init_phase3___start_all() {
}
// Initialized monitor, no matter if it will be started or not
GloMyMon = new MySQL_Monitor();
GloPgMon = new PgSQL_Monitor();
// load all mysql servers to GloHGH
{
cpu_timer t;
@ -1427,6 +1447,8 @@ void ProxySQL_Main_init_phase3___start_all() {
// Load the config not previously loaded for these modules
GloAdmin->load_http_server();
GloAdmin->load_restapi_server();
pgsql_monitor_thread = new std::thread(&PgSQL_monitor_scheduler_thread);
}

Write Preview
Loading…
Cancel
Save