aherman
/
proxysql
mirror of https://github.com/sysown/proxysql
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '200fdecb8d'
${ noResults }
proxysql/lib/ProxySQL_Config.cpp

2339 lines
85 KiB
Raw Blame History

#include "proxysql_config.h"
#include "re2/re2.h"
#include "proxysql.h"
#include "cpp.h"
#include "sqlite3db.h"
#include "proxysql_debug.h"
#include <sstream>
#include <set>
#include <tuple>
#include <cstring>
#include <memory>
const char* config_header = "########################################################################################\n"
"# This config file is parsed using libconfig , and its grammar is described in:\n"
"# http://www.hyperrealm.com/libconfig/libconfig_manual.html#Configuration-File-Grammar\n"
"# Grammar is also copied at the end of this file\n"
"########################################################################################\n"
"\n"
"########################################################################################\n"
"# IMPORTANT INFORMATION REGARDING THIS CONFIGURATION FILE:\n"
"########################################################################################\n"
"# On startup, ProxySQL reads its config file (if present) to determine its datadir.\n"
"# What happens next depends on if the database file (disk) is present in the defined\n"
"# datadir (i.e. \"/var/lib/proxysql/proxysql.db\").\n"
"#\n"
"# If the database file is found, ProxySQL initializes its in-memory configuration from\n"
"# the persisted on-disk database. So, disk configuration gets loaded into memory and\n"
"# then propagated towards the runtime configuration.\n"
"#\n"
"# If the database file is not found and a config file exists, the config file is parsed\n"
"# and its content is loaded into the in-memory database, to then be both saved on-disk\n"
"# database and loaded at runtime.\n"
"#\n"
"# IMPORTANT: If a database file is found, the config file is NOT parsed. In this case\n"
"# ProxySQL initializes its in-memory configuration from the persisted on-disk\n"
"# database ONLY. In other words, the configuration found in the proxysql.cnf\n"
"# file is only used to initial the on-disk database read on the first startup.\n"
"#\n"
"# In order to FORCE a re-initialise of the on-disk database from the configuration file\n"
"# the ProxySQL service should be started with \"service proxysql initial\".\n"
"#\n"
"########################################################################################\n";
ProxySQL_Config::ProxySQL_Config(SQLite3DB* db) {
assert(db);
admindb = db;
}
ProxySQL_Config:: ~ProxySQL_Config() {
}
void ProxySQL_Config::addField(std::string& data, const char* name, const char* value, const char* dq) {
std::stringstream ss;
if (!value || !strlen(value)) return;
// Escape the double quotes in all the fields contents
std::string esc_value { value };
RE2::GlobalReplace(&esc_value, "\"", "\\\\\"");
ss << "\t\t" << name << "=" << dq << esc_value.c_str() << dq << "\n";
data += ss.str();
}
/**
* @brief Reads global variables from configuration file for a given module prefix.
*
* This function parses the configuration file section named `<prefix>_variables`
* (e.g., "mysql_variables", "pgsql_variables", "admin_variables") and inserts
* the variables into the global_variables table in the format "prefix-variable_name".
*
* The function automatically strips duplicate module prefixes from variable names.
* For example, if a user writes "mysql-log_unhealthy_connections" in the mysql_variables
* section, the prefix "mysql-" is automatically removed, and the variable is stored
* as "mysql-log_unhealthy_connections" (with a single prefix).
*
* @param prefix The module prefix: "mysql", "pgsql", or "admin".
* @return Number of variables processed (successfully read and stored).
* @retval 0 if the prefix_variables section does not exist in the config file.
*
* @note The function temporarily disables foreign keys for performance.
* @note Variable values are converted to strings: booleans become "true"/"false",
* integers are converted via std::to_string, and strings are used as-is.
*
* @par Example:
* For prefix="mysql", the function reads the "mysql_variables" section from config.
* If the config contains "mysql-log_unhealthy_connections=false", it's stored as
* "mysql-log_unhealthy_connections" with value "false".
*
* @see ProxySQL_Config::Write_Global_Variables_to_configfile()
*/
int ProxySQL_Config::Read_Global_Variables_from_configfile(const char *prefix) {
const Setting& root = GloVars.confFile->cfg.getRoot();
char *groupname=(char *)malloc(strlen(prefix)+strlen((char *)"_variables")+1);
sprintf(groupname,"%s%s",prefix,"_variables");
if (root.exists(groupname)==false) {
free(groupname);
return 0;
}
const Setting &group = root[(const char *)groupname];
int count = group.getLength();
//fprintf(stderr, "Found %d %s_variables\n",count, prefix);
int i;
size_t prefix_len = strlen(prefix);
admindb->execute("PRAGMA foreign_keys = OFF");
// Prepare statement once for all inserts
auto [rc, stmt] = admindb->prepare_v2("INSERT OR REPLACE INTO global_variables VALUES (?1, ?2)");
if (rc != SQLITE_OK) {
proxy_error("Failed to prepare statement for global_variables insert: %d\n", rc);
admindb->execute("PRAGMA foreign_keys = ON");
free(groupname);
return 0;
}
for (i=0; i< count; i++) {
const Setting &sett = group[i];
const char *n=sett.getName();
bool value_bool;
int value_int;
std::string value_string="";
if (group.lookupValue(n, value_bool)) {
value_string = (value_bool ? "true" : "false");
} else {
if (group.lookupValue(n, value_int)) {
value_string = std::to_string(value_int);
} else {
group.lookupValue(n, value_string);
}
}
//fprintf(stderr,"%s = %s\n", n, value_string.c_str());
// Automatic prefix stripping: if variable already starts with "prefix-", remove it
if (strncmp(n, prefix, prefix_len) == 0 && n[prefix_len] == '-') {
n += prefix_len + 1; // Skip "prefix-"
}
// Construct full variable name
std::string full_var_name = std::string(prefix) + "-" + n;
rc = (*proxy_sqlite3_bind_text)(stmt.get(), 1, full_var_name.c_str(), -1, SQLITE_TRANSIENT);
ASSERT_SQLITE_OK(rc, admindb);
rc = (*proxy_sqlite3_bind_text)(stmt.get(), 2, value_string.c_str(), -1, SQLITE_TRANSIENT);
ASSERT_SQLITE_OK(rc, admindb);
SAFE_SQLITE3_STEP2(stmt.get());
rc = (*proxy_sqlite3_clear_bindings)(stmt.get());
ASSERT_SQLITE_OK(rc, admindb);
rc = (*proxy_sqlite3_reset)(stmt.get());
ASSERT_SQLITE_OK(rc, admindb);
}
// Statement automatically finalized when stmt goes out of scope
admindb->execute("PRAGMA foreign_keys = ON");
free(groupname);
return i;
}
int ProxySQL_Config::Write_MySQL_Users_to_configfile(std::string& data) {
char* error = NULL;
int cols = 0;
int affected_rows = 0;
SQLite3_result* sqlite_resultset = NULL;
char *query=(char *)"SELECT * FROM mysql_users";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from mysql_users: %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
data += "mysql_users:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "username", r->fields[0]);
addField(data, "password", r->fields[1]);
addField(data, "active", r->fields[2], "");
addField(data, "use_ssl", r->fields[3], "");
addField(data, "default_hostgroup", r->fields[4], "");
addField(data, "default_schema", r->fields[5]);
addField(data, "schema_locked", r->fields[6], "");
addField(data, "transaction_persistent", r->fields[7], "");
addField(data, "fast_forward", r->fields[8], "");
addField(data, "backend", r->fields[9], "");
addField(data, "frontend", r->fields[10], "");
addField(data, "max_connections", r->fields[11], "");
addField(data, "attributes", r->fields[12]);
addField(data, "comment", r->fields[13]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
return 0;
}
int ProxySQL_Config::Read_MySQL_Users_from_configfile(std::string& error) {
const Setting& root = GloVars.confFile->cfg.getRoot();
if (root.exists("mysql_users")==false) return 0;
const Setting &mysql_users = root["mysql_users"];
int count = mysql_users.getLength();
if (!validate_backend_users(PROXYSQL_CONFIG_MYSQL_USERS, mysql_users, error)) {
proxy_error("Admin: %s\n", error.c_str());
return -1;
}
int rows=0;
admindb->execute("PRAGMA foreign_keys = OFF");
char *q=(char *)"INSERT OR REPLACE INTO mysql_users (username, password, active, use_ssl, default_hostgroup, default_schema, schema_locked, transaction_persistent, fast_forward, max_connections, attributes, comment) VALUES ('%s', '%s', %d, %d, %d, '%s', %d, %d, %d, %d, '%s','%s')";
for (int i=0; i< count; i++) {
const Setting &user = mysql_users[i];
std::string username;
std::string password="";
int active=1;
int use_ssl=0;
int default_hostgroup=0;
std::string default_schema="";
int schema_locked=0;
int transaction_persistent=1;
int fast_forward=0;
int max_connections=10000;
std::string comment="";
std::string attributes="";
user.lookupValue("username", username);
user.lookupValue("password", password);
user.lookupValue("default_hostgroup", default_hostgroup);
user.lookupValue("active", active);
user.lookupValue("use_ssl", use_ssl);
//if (user.lookupValue("default_schema", default_schema)==false) default_schema="";
user.lookupValue("default_schema", default_schema);
user.lookupValue("schema_locked", schema_locked);
user.lookupValue("transaction_persistent", transaction_persistent);
user.lookupValue("fast_forward", fast_forward);
user.lookupValue("max_connections", max_connections);
user.lookupValue("attributes", attributes);
user.lookupValue("comment", comment);
char *o1=strdup(comment.c_str());
char *o=escape_string_single_quotes(o1, false);
char *query=(char *)malloc(strlen(q)+strlen(username.c_str())+strlen(password.c_str())+strlen(o)+strlen(attributes.c_str())+128);
sprintf(query,q, username.c_str(), password.c_str(), active, use_ssl, default_hostgroup, default_schema.c_str(), schema_locked, transaction_persistent, fast_forward, max_connections, attributes.c_str(), o);
admindb->execute(query);
if (o!=o1) free(o);
free(o1);
free(query);
rows++;
}
admindb->execute("PRAGMA foreign_keys = ON");
return rows;
}
int ProxySQL_Config::Write_Scheduler_to_configfile(std::string& data) {
char* error = NULL;
int cols = 0;
int affected_rows = 0;
SQLite3_result* sqlite_resultset = NULL;
char *query=(char *)"SELECT * FROM scheduler";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from scheduler: %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
data += "scheduler:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "id", r->fields[0], "");
addField(data, "active", r->fields[1], "");
addField(data, "interval_ms", r->fields[2], "");
addField(data, "filename", r->fields[3]);
addField(data, "arg1", r->fields[4]);
addField(data, "arg2", r->fields[5]);
addField(data, "arg3", r->fields[6]);
addField(data, "arg4", r->fields[7]);
addField(data, "arg5", r->fields[8]);
addField(data, "comment", r->fields[9]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
return 0;
}
int ProxySQL_Config::Read_Scheduler_from_configfile() {
const Setting& root = GloVars.confFile->cfg.getRoot();
if (root.exists("scheduler")==false) return 0;
const Setting &schedulers = root["scheduler"];
int count = schedulers.getLength();
//fprintf(stderr, "Found %d users\n",count);
int i;
int rows=0;
admindb->execute("PRAGMA foreign_keys = OFF");
char *q=(char *)"INSERT OR REPLACE INTO scheduler (id, active, interval_ms, filename, arg1, arg2, arg3, arg4, arg5, comment) VALUES (%d, %d, %d, '%s', %s, %s, %s, %s, %s, '%s')";
for (i=0; i< count; i++) {
const Setting &sched = schedulers[i];
int id;
int active=1;
std::string filename;
bool arg1_exists=false;
std::string arg1;
bool arg2_exists=false;
std::string arg2;
bool arg3_exists=false;
std::string arg3;
bool arg4_exists=false;
std::string arg4;
bool arg5_exists=false;
std::string arg5;
// variable for parsing interval_ms
int interval_ms=0;
std::string comment="";
// validate arguments
if (sched.lookupValue("id", id)==false) {
proxy_error("Admin: detected a scheduler in config file without a mandatory id\n");
continue;
}
sched.lookupValue("active", active);
sched.lookupValue("interval_ms", interval_ms);
if (sched.lookupValue("filename", filename)==false) {
proxy_error("Admin: detected a scheduler in config file without a mandatory filename\n");
continue;
}
if (sched.lookupValue("arg1", arg1)) arg1_exists=true;
if (sched.lookupValue("arg2", arg2)) arg2_exists=true;
if (sched.lookupValue("arg3", arg3)) arg3_exists=true;
if (sched.lookupValue("arg4", arg4)) arg4_exists=true;
if (sched.lookupValue("arg5", arg5)) arg5_exists=true;
sched.lookupValue("comment", comment);
int query_len=0;
query_len+=strlen(q) +
strlen(std::to_string(id).c_str()) +
strlen(std::to_string(active).c_str()) +
strlen(std::to_string(interval_ms).c_str()) +
strlen(filename.c_str()) +
( arg1_exists ? strlen(arg1.c_str()) : 0 ) + 4 +
( arg2_exists ? strlen(arg2.c_str()) : 0 ) + 4 +
( arg3_exists ? strlen(arg3.c_str()) : 0 ) + 4 +
( arg4_exists ? strlen(arg4.c_str()) : 0 ) + 4 +
( arg5_exists ? strlen(arg5.c_str()) : 0 ) + 4 +
strlen(comment.c_str()) +
40;
char *query=(char *)malloc(query_len);
if (arg1_exists)
arg1="\'" + arg1 + "\'";
else
arg1 = "NULL";
if (arg2_exists)
arg2="\'" + arg2 + "\'";
else
arg2 = "NULL";
if (arg3_exists)
arg3="\'" + arg3 + "\'";
else
arg3 = "NULL";
if (arg4_exists)
arg4="\'" + arg4 + "\'";
else
arg4 = "NULL";
if (arg5_exists)
arg5="\'" + arg5 + "\'";
else
arg5 = "NULL";
sprintf(query, q,
id, active,
interval_ms,
filename.c_str(),
arg1.c_str(),
arg2.c_str(),
arg3.c_str(),
arg4.c_str(),
arg5.c_str(),
comment.c_str()
);
admindb->execute(query);
free(query);
rows++;
}
admindb->execute("PRAGMA foreign_keys = ON");
return rows;
}
int ProxySQL_Config::Write_Restapi_to_configfile(std::string& data) {
char* error = NULL;
int cols = 0;
int affected_rows = 0;
SQLite3_result* sqlite_resultset = NULL;
char *query=(char *)"SELECT * FROM restapi_routes";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from restapi_router: %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
data += "restapi:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "id", r->fields[0], "");
addField(data, "active", r->fields[1], "");
addField(data, "timeout_ms", r->fields[2], "");
addField(data, "method", r->fields[3], "");
addField(data, "uri", r->fields[4]);
addField(data, "script", r->fields[5]);
addField(data, "comment", r->fields[6]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
return 0;
}
int ProxySQL_Config::Read_Restapi_from_configfile() {
const Setting& root = GloVars.confFile->cfg.getRoot();
if (root.exists("restapi")==false) return 0;
const Setting &routes = root["restapi"];
int count = routes.getLength();
//fprintf(stderr, "Found %d users\n",count);
int i;
int rows=0;
admindb->execute("PRAGMA foreign_keys = OFF");
char *q=(char *)"INSERT OR REPLACE INTO restapi_routes VALUES (%d, %d, %d, '%s', '%s', '%s', '%s')";
for (i=0; i< count; i++) {
const Setting &route = routes[i];
int id;
int active=1;
// variable for parsing timeout_ms
int timeout_ms=0;
std::string method;
std::string uri;
std::string script;
std::string comment="";
// validate arguments
if (route.lookupValue("id", id)==false) {
proxy_error("Admin: detected a restapi route in config file without a mandatory id\n");
continue;
}
route.lookupValue("active", active);
if (route.lookupValue("interval_ms", timeout_ms) == false) {
route.lookupValue("timeout_ms", timeout_ms);
}
if (route.lookupValue("method", method)==false) {
proxy_error("Admin: detected a restapi route in config file without a mandatory method\n");
continue;
}
if (route.lookupValue("uri", uri)==false) {
proxy_error("Admin: detected a restapi route in config file without a mandatory uri\n");
continue;
}
if (route.lookupValue("script", script)==false) {
proxy_error("Admin: detected a restapi route in config file without a mandatory script\n");
continue;
}
route.lookupValue("comment", comment);
int query_len=0;
query_len+=strlen(q) +
strlen(std::to_string(id).c_str()) +
strlen(std::to_string(active).c_str()) +
strlen(std::to_string(timeout_ms).c_str()) +
strlen(method.c_str()) +
strlen(uri.c_str()) +
strlen(script.c_str()) +
strlen(comment.c_str()) +
40;
char *query=(char *)malloc(query_len);
sprintf(query, q,
id, active,
timeout_ms,
method.c_str(),
uri.c_str(),
script.c_str(),
comment.c_str()
);
admindb->execute(query);
free(query);
rows++;
}
admindb->execute("PRAGMA foreign_keys = ON");
return rows;
}
int ProxySQL_Config::Write_MySQL_Query_Rules_to_configfile(std::string& data) {
char* error = NULL;
int cols = 0;
int affected_rows = 0;
SQLite3_result* sqlite_resultset = NULL;
char *query=(char *)"SELECT * FROM mysql_query_rules";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from mysql_query_rules : %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
std::string prefix;
data += "mysql_query_rules:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "rule_id", r->fields[0], "");
addField(data, "active", r->fields[1], "");
addField(data, "username", r->fields[2]);
addField(data, "schemaname", r->fields[3]);
addField(data, "flagIN", r->fields[4], "");
addField(data, "client_addr", r->fields[5]);
addField(data, "proxy_addr", r->fields[6]);
addField(data, "proxy_port", r->fields[7], "");
addField(data, "digest", r->fields[8]);
addField(data, "match_digest", r->fields[9]);
addField(data, "match_pattern", r->fields[10]);
addField(data, "negate_match_pattern", r->fields[11], "");
addField(data, "re_modifiers", r->fields[12]);
addField(data, "flagOUT", r->fields[13], "");
addField(data, "replace_pattern", r->fields[14]);
addField(data, "destination_hostgroup", r->fields[15], "");
addField(data, "cache_ttl", r->fields[16], "");
addField(data, "cache_empty_result", r->fields[17], "");
addField(data, "cache_timeout", r->fields[18], "");
addField(data, "reconnect", r->fields[19], "");
addField(data, "timeout", r->fields[20], "");
addField(data, "retries", r->fields[21], "");
addField(data, "delay", r->fields[22], "");
addField(data, "next_query_flagIN", r->fields[23], "");
addField(data, "mirror_flagOUT", r->fields[24], "");
addField(data, "mirror_hostgroup", r->fields[25], "");
addField(data, "error_msg", r->fields[26]);
addField(data, "OK_msg", r->fields[27]);
addField(data, "sticky_conn", r->fields[28], "");
addField(data, "multiplex", r->fields[29], "");
addField(data, "gtid_from_hostgroup", r->fields[30], "");
addField(data, "log", r->fields[31], "");
addField(data, "apply", r->fields[32], "");
addField(data, "attributes", r->fields[33]);
addField(data, "comment", r->fields[34]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
return 0;
}
int ProxySQL_Config::Read_MySQL_Query_Rules_from_configfile() {
const Setting& root = GloVars.confFile->cfg.getRoot();
if (root.exists("mysql_query_rules")==false) return 0;
const Setting &mysql_query_rules = root["mysql_query_rules"];
int count = mysql_query_rules.getLength();
//fprintf(stderr, "Found %d users\n",count);
int i;
int rows=0;
admindb->execute("PRAGMA foreign_keys = OFF");
char *q=(char *)"INSERT OR REPLACE INTO mysql_query_rules (rule_id, active, username, schemaname, flagIN, client_addr, proxy_addr, proxy_port, digest, match_digest, match_pattern, negate_match_pattern, re_modifiers, flagOUT, replace_pattern, destination_hostgroup, cache_ttl, cache_empty_result, cache_timeout, reconnect, timeout, retries, delay, next_query_flagIN, mirror_flagOUT, mirror_hostgroup, error_msg, ok_msg, sticky_conn, multiplex, gtid_from_hostgroup, log, apply, attributes, comment) VALUES (%d, %d, %s, %s, %s, %s, %s, %s, %s, %s, %s, %d, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %d, %s, %s)";
for (i=0; i< count; i++) {
const Setting &rule = mysql_query_rules[i];
int rule_id;
int active=1;
bool username_exists=false;
std::string username;
bool schemaname_exists=false;
std::string schemaname;
int flagIN=0;
// variables for parsing client_addr
bool client_addr_exists=false;
std::string client_addr;
// variables for parsing proxy_addr
bool proxy_addr_exists=false;
std::string proxy_addr;
// variable for parsing proxy_port
int proxy_port=-1;
// variables for parsing digest
bool digest_exists=false;
std::string digest;
bool match_digest_exists=false;
std::string match_digest;
bool match_pattern_exists=false;
std::string match_pattern;
int negate_match_pattern=0;
bool re_modifiers_exists=false;
std::string re_modifiers;
int flagOUT=-1;
bool replace_pattern_exists=false;
std::string replace_pattern;
int destination_hostgroup=-1;
int next_query_flagIN=-1;
int mirror_flagOUT=-1;
int mirror_hostgroup=-1;
int cache_ttl=-1;
int cache_empty_result=-1;
int cache_timeout=-1;
int reconnect=-1;
int timeout=-1;
int retries=-1;
int delay=-1;
bool error_msg_exists=false;
std::string error_msg;
bool OK_msg_exists=false;
std::string OK_msg;
int sticky_conn=-1;
int multiplex=-1;
int gtid_from_hostgroup = -1;
// variable for parsing log
int log=-1;
int apply=0;
// attributes
bool attributes_exists=false;
std::string attributes {};
bool comment_exists=false;
std::string comment;
// validate arguments
if (rule.lookupValue("rule_id", rule_id)==false) {
proxy_error("Admin: detected a mysql_query_rules in config file without a mandatory rule_id\n");
continue;
}
rule.lookupValue("active", active);
if (rule.lookupValue("username", username)) username_exists=true;
if (rule.lookupValue("schemaname", schemaname)) schemaname_exists=true;
rule.lookupValue("flagIN", flagIN);
if (rule.lookupValue("client_addr", client_addr)) client_addr_exists=true;
if (rule.lookupValue("proxy_addr", proxy_addr)) proxy_addr_exists=true;
rule.lookupValue("proxy_port", proxy_port);
if (rule.lookupValue("digest", digest)) digest_exists=true;
if (rule.lookupValue("match_digest", match_digest)) match_digest_exists=true;
if (rule.lookupValue("match_pattern", match_pattern)) match_pattern_exists=true;
rule.lookupValue("negate_match_pattern", negate_match_pattern);
if (rule.lookupValue("re_modifiers", re_modifiers)) {
} else {
re_modifiers = "CASELESS";
}
re_modifiers_exists=true;
rule.lookupValue("flagOUT", flagOUT);
if (rule.lookupValue("replace_pattern", replace_pattern)) replace_pattern_exists=true;
rule.lookupValue("destination_hostgroup", destination_hostgroup);
rule.lookupValue("next_query_flagIN", next_query_flagIN);
rule.lookupValue("mirror_flagOUT", mirror_flagOUT);
rule.lookupValue("mirror_hostgroup", mirror_hostgroup);
rule.lookupValue("cache_ttl", cache_ttl);
rule.lookupValue("cache_empty_result", cache_empty_result);
rule.lookupValue("cache_timeout", cache_timeout);
rule.lookupValue("reconnect", reconnect);
rule.lookupValue("timeout", timeout);
rule.lookupValue("retries", retries);
rule.lookupValue("delay", delay);
if (rule.lookupValue("error_msg", error_msg)) error_msg_exists=true;
if (rule.lookupValue("OK_msg", OK_msg)) OK_msg_exists=true;
rule.lookupValue("sticky_conn", sticky_conn);
rule.lookupValue("multiplex", multiplex);
rule.lookupValue("gtid_from_hostgroup", gtid_from_hostgroup);
rule.lookupValue("log", log);
rule.lookupValue("apply", apply);
if (rule.lookupValue("comment", comment)) comment_exists=true;
if (rule.lookupValue("attributes", attributes)) attributes_exists=true;
//if (user.lookupValue("default_schema", default_schema)==false) default_schema="";
int query_len=0;
query_len+=strlen(q) +
strlen(std::to_string(rule_id).c_str()) +
strlen(std::to_string(active).c_str()) +
( username_exists ? strlen(username.c_str()) : 0 ) + 4 +
( schemaname_exists ? strlen(schemaname.c_str()) : 0 ) + 4 +
strlen(std::to_string(flagIN).c_str()) + 4 +
( client_addr_exists ? strlen(client_addr.c_str()) : 0 ) + 4 +
( proxy_addr_exists ? strlen(proxy_addr.c_str()) : 0 ) + 4 +
strlen(std::to_string(proxy_port).c_str()) + 4 +
( match_digest_exists ? strlen(match_digest.c_str()) : 0 ) + 4 +
( match_pattern_exists ? strlen(match_pattern.c_str()) : 0 ) + 4 +
strlen(std::to_string(negate_match_pattern).c_str()) + 4 +
( re_modifiers_exists ? strlen(re_modifiers.c_str()) : 0 ) + 4 +
strlen(std::to_string(flagOUT).c_str()) + 4 +
( replace_pattern_exists ? strlen(replace_pattern.c_str()) : 0 ) + 4 +
strlen(std::to_string(destination_hostgroup).c_str()) + 4 +
strlen(std::to_string(cache_ttl).c_str()) + 4 +
strlen(std::to_string(cache_empty_result).c_str()) + 4 +
strlen(std::to_string(cache_timeout).c_str()) + 4 +
strlen(std::to_string(reconnect).c_str()) + 4 +
strlen(std::to_string(timeout).c_str()) + 4 +
strlen(std::to_string(next_query_flagIN).c_str()) + 4 +
strlen(std::to_string(mirror_flagOUT).c_str()) + 4 +
strlen(std::to_string(mirror_hostgroup).c_str()) + 4 +
strlen(std::to_string(retries).c_str()) + 4 +
strlen(std::to_string(delay).c_str()) + 4 +
( error_msg_exists ? strlen(error_msg.c_str()) : 0 ) + 4 +
( OK_msg_exists ? strlen(OK_msg.c_str()) : 0 ) + 4 +
strlen(std::to_string(sticky_conn).c_str()) + 4 +
strlen(std::to_string(multiplex).c_str()) + 4 +
strlen(std::to_string(gtid_from_hostgroup).c_str()) + 4 +
strlen(std::to_string(log).c_str()) + 4 +
strlen(std::to_string(apply).c_str()) + 4 +
( attributes_exists ? strlen(attributes.c_str()) : 0 ) + 4 +
( comment_exists ? strlen(comment.c_str()) : 0 ) + 4 +
64;
char *query=(char *)malloc(query_len);
if (username_exists)
username="\"" + username + "\"";
else
username = "NULL";
if (schemaname_exists)
schemaname="\"" + schemaname + "\"";
else
schemaname = "NULL";
if (client_addr_exists)
client_addr="\"" + client_addr + "\"";
else
client_addr = "NULL";
if (proxy_addr_exists)
proxy_addr="\"" + proxy_addr + "\"";
else
proxy_addr = "NULL";
if (digest_exists)
digest="\"" + digest + "\"";
else
digest = "NULL";
if (match_digest_exists)
match_digest="\"" + match_digest + "\"";
else
match_digest = "NULL";
if (match_pattern_exists)
match_pattern="\"" + match_pattern + "\"";
else
match_pattern = "NULL";
if (replace_pattern_exists)
replace_pattern="\"" + replace_pattern + "\"";
else
replace_pattern = "NULL";
if (error_msg_exists)
error_msg="\"" + error_msg + "\"";
else
error_msg = "NULL";
if (OK_msg_exists)
OK_msg="\"" + OK_msg + "\"";
else
OK_msg = "NULL";
if (re_modifiers_exists)
re_modifiers="\"" + re_modifiers + "\"";
else
re_modifiers = "NULL";
if (attributes_exists)
attributes="'" + attributes + "'";
else
attributes = "NULL";
if (comment_exists)
comment="'" + comment + "'";
else
comment = "NULL";
sprintf(query, q,
rule_id, active,
username.c_str(),
schemaname.c_str(),
( flagIN >= 0 ? std::to_string(flagIN).c_str() : "NULL") ,
client_addr.c_str(),
proxy_addr.c_str(),
( proxy_port >= 0 ? std::to_string(proxy_port).c_str() : "NULL") ,
digest.c_str(),
match_digest.c_str(),
match_pattern.c_str(),
( negate_match_pattern == 0 ? 0 : 1) ,
re_modifiers.c_str(),
( flagOUT >= 0 ? std::to_string(flagOUT).c_str() : "NULL") ,
replace_pattern.c_str(),
( destination_hostgroup >= 0 ? std::to_string(destination_hostgroup).c_str() : "NULL") ,
( cache_ttl >= 0 ? std::to_string(cache_ttl).c_str() : "NULL") ,
( cache_empty_result >= 0 ? std::to_string(cache_empty_result).c_str() : "NULL") ,
( cache_timeout >= 0 ? std::to_string(cache_timeout).c_str() : "NULL") ,
( reconnect >= 0 ? std::to_string(reconnect).c_str() : "NULL") ,
( timeout >= 0 ? std::to_string(timeout).c_str() : "NULL") ,
( retries >= 0 ? std::to_string(retries).c_str() : "NULL") ,
( delay >= 0 ? std::to_string(delay).c_str() : "NULL") ,
( next_query_flagIN >= 0 ? std::to_string(next_query_flagIN).c_str() : "NULL") ,
( mirror_flagOUT >= 0 ? std::to_string(mirror_flagOUT).c_str() : "NULL") ,
( mirror_hostgroup >= 0 ? std::to_string(mirror_hostgroup).c_str() : "NULL") ,
error_msg.c_str(),
OK_msg.c_str(),
( sticky_conn >= 0 ? std::to_string(sticky_conn).c_str() : "NULL") ,
( multiplex >= 0 ? std::to_string(multiplex).c_str() : "NULL") ,
( gtid_from_hostgroup >= 0 ? std::to_string(gtid_from_hostgroup).c_str() : "NULL") ,
( log >= 0 ? std::to_string(log).c_str() : "NULL") ,
( apply == 0 ? 0 : 1) ,
attributes.c_str(),
comment.c_str()
);
//fprintf(stderr, "%s\n", query);
admindb->execute(query);
free(query);
rows++;
}
admindb->execute("PRAGMA foreign_keys = ON");
return rows;
}
int ProxySQL_Config::Write_MySQL_Servers_to_configfile(std::string& data) {
char* error = NULL;
int cols = 0;
int affected_rows = 0;
SQLite3_result* sqlite_resultset = NULL;
char *query=(char *)"SELECT * FROM mysql_servers";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from mysql_query_rules : %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
data += "mysql_servers:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "hostgroup_id", r->fields[0], "");
addField(data, "hostname", r->fields[1]);
addField(data, "port", r->fields[2], "");
addField(data, "gtid_port", r->fields[3], "");
addField(data, "status", r->fields[4]);
addField(data, "weight", r->fields[5], "");
addField(data, "compression", r->fields[6], "");
addField(data, "max_connections", r->fields[7], "");
addField(data, "max_replication_lag", r->fields[8], "");
addField(data, "use_ssl", r->fields[9], "");
addField(data, "max_latency_ms", r->fields[10], "");
addField(data, "comment", r->fields[11]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
query=(char *)"SELECT * FROM mysql_replication_hostgroups";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from mysql_replication_hostgroups : %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
data += "mysql_replication_hostgroups:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "writer_hostgroup", r->fields[0], "");
addField(data, "reader_hostgroup", r->fields[1], "");
addField(data, "check_type", r->fields[2]);
addField(data, "comment", r->fields[3]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
query=(char *)"SELECT * FROM mysql_group_replication_hostgroups";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from mysql_group_replication_hostgroups : %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
data += "mysql_group_replication_hostgroups:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "writer_hostgroup", r->fields[0], "");
addField(data, "backup_writer_hostgroup", r->fields[1], "");
addField(data, "reader_hostgroup", r->fields[2], "");
addField(data, "offline_hostgroup", r->fields[3], "");
addField(data, "active", r->fields[4], "");
addField(data, "max_writers", r->fields[5], "");
addField(data, "writer_is_also_reader", r->fields[6], "");
addField(data, "max_transactions_behind", r->fields[7], "");
addField(data, "comment", r->fields[8]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
query=(char *)"SELECT * FROM mysql_galera_hostgroups";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from mysql_galera_hostgroups: %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
data += "mysql_galera_hostgroups:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "writer_hostgroup", r->fields[0], "");
addField(data, "backup_writer_hostgroup", r->fields[1], "");
addField(data, "reader_hostgroup", r->fields[2], "");
addField(data, "offline_hostgroup", r->fields[3], "");
addField(data, "active", r->fields[4], "");
addField(data, "max_writers", r->fields[5], "");
addField(data, "writer_is_also_reader", r->fields[6], "");
addField(data, "max_transactions_behind", r->fields[7], "");
addField(data, "comment", r->fields[8]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
query=(char *)"SELECT * FROM mysql_aws_aurora_hostgroups";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from mysql_aws_aurora_hostgroups: %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
data += "mysql_aws_aurora_hostgroups:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "writer_hostgroup", r->fields[0], "");
addField(data, "reader_hostgroup", r->fields[1], "");
addField(data, "active", r->fields[2], "");
addField(data, "aurora_port", r->fields[3], "");
addField(data, "domain_name", r->fields[4]);
addField(data, "max_lag_ms", r->fields[5], "");
addField(data, "check_interval_ms", r->fields[6], "");
addField(data, "check_timeout_ms", r->fields[7], "");
addField(data, "writer_is_also_reader", r->fields[8], "");
addField(data, "new_reader_weight", r->fields[9], "");
addField(data, "add_lag_ms", r->fields[10], "");
addField(data, "min_lag_ms", r->fields[11], "");
addField(data, "lag_num_checks", r->fields[12], "");
addField(data, "comment", r->fields[13]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
query = (char *)"SELECT * FROM mysql_hostgroup_attributes";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from mysql_hostgroup_attributes: %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
data += "mysql_hostgroup_attributes:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "hostgroup_id", r->fields[0], "");
addField(data, "max_num_online_servers", r->fields[1], "");
addField(data, "autocommit", r->fields[2], "");
addField(data, "free_connections_pct", r->fields[3], "");
addField(data, "init_connect", r->fields[4]);
addField(data, "multiplex", r->fields[5], "");
addField(data, "connection_warming", r->fields[6], "");
addField(data, "throttle_connections_per_sec", r->fields[7], "");
addField(data, "ignore_session_variables", r->fields[8]);
addField(data, "hostgroup_settings", r->fields[9]);
addField(data, "servers_defaults", r->fields[10]);
addField(data, "comment", r->fields[11]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
return 0;
}
int ProxySQL_Config::Read_MySQL_Servers_from_configfile(std::string& error) {
const Setting& root = GloVars.confFile->cfg.getRoot();
int i;
int rows=0;
admindb->execute("PRAGMA foreign_keys = OFF");
if (root.exists("mysql_servers")==true) {
const Setting &mysql_servers = root["mysql_servers"];
int count = mysql_servers.getLength();
if (!validate_backend_servers(PROXYSQL_CONFIG_MYSQL_SERVERS, mysql_servers, error)) {
proxy_error("Admin: %s\n", error.c_str());
return -1;
}
char *q=(char *)"INSERT OR REPLACE INTO mysql_servers (hostname, port, gtid_port, hostgroup_id, compression, weight, status, max_connections, max_replication_lag, use_ssl, max_latency_ms, comment) VALUES (\"%s\", %d, %d, %d, %d, %d, \"%s\", %d, %d, %d, %d, '%s')";
for (i=0; i< count; i++) {
const Setting &server = mysql_servers[i];
std::string address;
std::string status="ONLINE";
int port=3306;
int gtid_port=0;
int hostgroup;
int weight=1;
int compression=0;
int max_connections=1000; // default
int max_replication_lag=0; // default
int use_ssl=0;
int max_latency_ms=0;
std::string comment="";
if (!server.lookupValue("address", address)) {
server.lookupValue("hostname", address);
}
if (!server.lookupValue("hostgroup", hostgroup)) {
server.lookupValue("hostgroup_id", hostgroup);
}
server.lookupValue("port", port);
server.lookupValue("gtid_port", gtid_port);
server.lookupValue("status", status);
if (
(strcasecmp(status.c_str(),(char *)"ONLINE"))
&& (strcasecmp(status.c_str(),(char *)"SHUNNED"))
&& (strcasecmp(status.c_str(),(char *)"OFFLINE_SOFT"))
&& (strcasecmp(status.c_str(),(char *)"OFFLINE_HARD"))
) {
status="ONLINE";
}
server.lookupValue("compression", compression);
server.lookupValue("weight", weight);
server.lookupValue("max_connections", max_connections);
server.lookupValue("max_replication_lag", max_replication_lag);
server.lookupValue("use_ssl", use_ssl);
server.lookupValue("max_latency_ms", max_latency_ms);
server.lookupValue("comment", comment);
char *o1=strdup(comment.c_str());
char *o=escape_string_single_quotes(o1, false);
char *query=(char *)malloc(strlen(q)+strlen(status.c_str())+strlen(address.c_str())+strlen(o)+128);
sprintf(query,q, address.c_str(), port, gtid_port, hostgroup, compression, weight, status.c_str(), max_connections, max_replication_lag, use_ssl, max_latency_ms, o);
//fprintf(stderr, "%s\n", query);
admindb->execute(query);
if (o!=o1) free(o);
free(o1);
free(query);
rows++;
}
}
// TODO: Add validation to mysql_replication_hostgroups similar to mysql_servers
if (root.exists("mysql_replication_hostgroups")==true) {
const Setting &mysql_replication_hostgroups = root["mysql_replication_hostgroups"];
int count = mysql_replication_hostgroups.getLength();
char *q=(char *)"INSERT OR REPLACE INTO mysql_replication_hostgroups (writer_hostgroup, reader_hostgroup, comment, check_type) VALUES (%d, %d, '%s', '%s')";
for (i=0; i< count; i++) {
const Setting &line = mysql_replication_hostgroups[i];
int writer_hostgroup;
int reader_hostgroup;
std::string comment="";
std::string check_type="";
if (line.lookupValue("writer_hostgroup", writer_hostgroup)==false) {
proxy_error("Admin: detected a mysql_replication_hostgroups in config file without a mandatory writer_hostgroup\n");
continue;
}
if (line.lookupValue("reader_hostgroup", reader_hostgroup)==false) {
proxy_error("Admin: detected a mysql_replication_hostgroups in config file without a mandatory reader_hostgroup\n");
continue;
}
line.lookupValue("comment", comment);
char *o1=strdup(comment.c_str());
char *o=escape_string_single_quotes(o1, false);
line.lookupValue("check_type", check_type);
if (
(strcasecmp(check_type.c_str(),(char *)"read_only"))
&& (strcasecmp(check_type.c_str(),(char *)"innodb_read_only"))
&& (strcasecmp(check_type.c_str(),(char *)"super_read_only"))
) {
check_type="read_only";
}
char *t1=strdup(check_type.c_str());
char *t=escape_string_single_quotes(t1, false);
char *query=(char *)malloc(strlen(q)+strlen(o)+strlen(t)+32);
sprintf(query,q, writer_hostgroup, reader_hostgroup, o, t);
//fprintf(stderr, "%s\n", query);
admindb->execute(query);
if (o!=o1) free(o);
free(o1);
if (t!=t1) free(t);
free(t1);
free(query);
rows++;
}
}
if (root.exists("mysql_servers_ssl_params")==true) { // mysql_servers_ssl_params
const Setting &mysql_servers_ssl_params = root["mysql_servers_ssl_params"];
int count = mysql_servers_ssl_params.getLength();
char *q=(char *)"INSERT OR REPLACE INTO mysql_servers_ssl_params (hostname, port, username, ssl_ca, ssl_cert, ssl_key, ssl_capath, ssl_crl, ssl_crlpath, ssl_cipher, tls_version, comment) VALUES ('%s', %d, '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s')";
for (i=0; i< count; i++) {
const Setting &line = mysql_servers_ssl_params[i];
string hostname = "";
int port = 3306;
string username = "";
string ssl_ca = "";
string ssl_cert = "";
string ssl_key = "";
string ssl_capath = "";
string ssl_crl = "";
string ssl_crlpath = "";
string ssl_cipher = "";
string tls_version = "";
std::string comment="";
if (line.lookupValue("hostname", hostname)==false) {
proxy_error("Admin: detected a mysql_servers_ssl_params in config file without a mandatory hostname\n");
continue;
}
line.lookupValue("port", port);
line.lookupValue("username", username);
line.lookupValue("ssl_ca", ssl_ca);
line.lookupValue("ssl_cert", ssl_cert);
line.lookupValue("ssl_key", ssl_key);
line.lookupValue("ssl_capath", ssl_capath);
line.lookupValue("ssl_crl", ssl_crl);
line.lookupValue("ssl_crlpath", ssl_crlpath);
line.lookupValue("ssl_cipher", ssl_cipher);
line.lookupValue("tls_version", tls_version);
line.lookupValue("comment", comment);
char *o1=strdup(comment.c_str());
char *o=escape_string_single_quotes(o1, false);
char *query=(char *)malloc(
strlen(q)
+ hostname.length() + username.length()
+ ssl_ca.length() + ssl_cert.length() + ssl_key.length() + ssl_capath.length()
+ ssl_crl.length() + ssl_crlpath.length() + ssl_cipher.length() + tls_version.length()
+ strlen(o) + 32);
sprintf(query, q,
hostname.c_str() , port , username.c_str() ,
ssl_ca.c_str() , ssl_cert.c_str() , ssl_key.c_str() , ssl_capath.c_str() ,
ssl_crl.c_str() , ssl_crlpath.c_str() , ssl_cipher.c_str() , tls_version.c_str() ,
o);
admindb->execute(query);
if (o!=o1) free(o);
free(o1);
free(query);
rows++;
}
}
if (root.exists("mysql_group_replication_hostgroups")==true) {
const Setting &mysql_group_replication_hostgroups = root["mysql_group_replication_hostgroups"];
int count = mysql_group_replication_hostgroups.getLength();
char *q=(char *)"INSERT OR REPLACE INTO mysql_group_replication_hostgroups (writer_hostgroup, backup_writer_hostgroup, reader_hostgroup, offline_hostgroup, active, max_writers, writer_is_also_reader, max_transactions_behind, comment) VALUES (%d, %d, %d, %d, %d, %d, %d, %d, '%s')";
for (i=0; i< count; i++) {
const Setting &line = mysql_group_replication_hostgroups[i];
int writer_hostgroup;
int backup_writer_hostgroup;
int reader_hostgroup;
int offline_hostgroup;
int active=1; // default
int max_writers;
int writer_is_also_reader;
int max_transactions_behind;
std::string comment="";
if (line.lookupValue("writer_hostgroup", writer_hostgroup)==false) {
proxy_error("Admin: detected a mysql_group_replication_hostgroups in config file without a mandatory writer_hostgroup\n");
continue;
}
if (line.lookupValue("backup_writer_hostgroup", backup_writer_hostgroup)==false) {
proxy_error("Admin: detected a mysql_group_replication_hostgroups in config file without a mandatory backup_writer_hostgroup\n");
continue;
}
if (line.lookupValue("reader_hostgroup", reader_hostgroup)==false) {
proxy_error("Admin: detected a mysql_group_replication_hostgroups in config file without a mandatory reader_hostgroup\n");
continue;
}
if (line.lookupValue("offline_hostgroup", offline_hostgroup)==false) {
proxy_error("Admin: detected a mysql_group_replication_hostgroups in config file without a mandatory offline_hostgroup\n");
continue;
}
if (line.lookupValue("max_writers", max_writers)==false) max_writers=1;
if (line.lookupValue("writer_is_also_reader", writer_is_also_reader)==false) writer_is_also_reader=0;
if (line.lookupValue("max_transactions_behind", max_transactions_behind)==false) max_transactions_behind=0;
line.lookupValue("comment", comment);
char *o1=strdup(comment.c_str());
char *o=escape_string_single_quotes(o1, false);
char *query=(char *)malloc(strlen(q)+strlen(o)+128); // 128 vs sizeof(int)*8
sprintf(query,q, writer_hostgroup, backup_writer_hostgroup, reader_hostgroup, offline_hostgroup, active, max_writers, writer_is_also_reader, max_transactions_behind, o);
//fprintf(stderr, "%s\n", query);
admindb->execute(query);
if (o!=o1) free(o);
free(o1);
free(query);
rows++;
}
}
if (root.exists("mysql_galera_hostgroups")==true) {
const Setting &mysql_galera_hostgroups = root["mysql_galera_hostgroups"];
int count = mysql_galera_hostgroups.getLength();
char *q=(char *)"INSERT OR REPLACE INTO mysql_galera_hostgroups (writer_hostgroup, backup_writer_hostgroup, reader_hostgroup, offline_hostgroup, active, max_writers, writer_is_also_reader, max_transactions_behind, comment) VALUES (%d, %d, %d, %d, %d, %d, %d, %d, '%s')";
for (i=0; i< count; i++) {
const Setting &line = mysql_galera_hostgroups[i];
int writer_hostgroup;
int backup_writer_hostgroup;
int reader_hostgroup;
int offline_hostgroup;
int active=1; // default
int max_writers;
int writer_is_also_reader;
int max_transactions_behind;
std::string comment="";
if (line.lookupValue("writer_hostgroup", writer_hostgroup)==false) {
proxy_error("Admin: detected a mysql_galera_hostgroups in config file without a mandatory writer_hostgroup\n");
continue;
}
if (line.lookupValue("backup_writer_hostgroup", backup_writer_hostgroup)==false) {
proxy_error("Admin: detected a mysql_galera_hostgroups in config file without a mandatory backup_writer_hostgroup\n");
continue;
}
if (line.lookupValue("reader_hostgroup", reader_hostgroup)==false) {
proxy_error("Admin: detected a mysql_galera_hostgroups in config file without a mandatory reader_hostgroup\n");
continue;
}
if (line.lookupValue("offline_hostgroup", offline_hostgroup)==false) {
proxy_error("Admin: detected a mysql_galera_hostgroups in config file without a mandatory offline_hostgroup\n");
continue;
}
if (line.lookupValue("max_writers", max_writers)==false) max_writers=1;
if (line.lookupValue("writer_is_also_reader", writer_is_also_reader)==false) writer_is_also_reader=0;
if (line.lookupValue("max_transactions_behind", max_transactions_behind)==false) max_transactions_behind=0;
line.lookupValue("comment", comment);
char *o1=strdup(comment.c_str());
char *o=escape_string_single_quotes(o1, false);
char *query=(char *)malloc(strlen(q)+strlen(o)+128); // 128 vs sizeof(int)*8
sprintf(query,q, writer_hostgroup, backup_writer_hostgroup, reader_hostgroup, offline_hostgroup, active, max_writers, writer_is_also_reader, max_transactions_behind, o);
//fprintf(stderr, "%s\n", query);
admindb->execute(query);
if (o!=o1) free(o);
free(o1);
free(query);
rows++;
}
}
if (root.exists("mysql_aws_aurora_hostgroups")==true) {
const Setting &mysql_aws_aurora_hostgroups = root["mysql_aws_aurora_hostgroups"];
int count = mysql_aws_aurora_hostgroups.getLength();
char *q=(char *)"INSERT OR REPLACE INTO mysql_aws_aurora_hostgroups (writer_hostgroup, reader_hostgroup, active, aurora_port, domain_name, max_lag_ms, check_interval_ms, check_timeout_ms, writer_is_also_reader, new_reader_weight, add_lag_ms, min_lag_ms, lag_num_checks, comment ) VALUES (%d, %d, %d, %d, '%s', %d, %d, %d, %d, %d, %d, %d, %d, '%s')";
for (i=0; i< count; i++) {
const Setting &line = mysql_aws_aurora_hostgroups[i];
int writer_hostgroup;
int reader_hostgroup;
int active=1; // default
int aurora_port;
int max_lag_ms;
int add_lag_ms;
int min_lag_ms;
int lag_num_checks;
int check_interval_ms;
int check_timeout_ms;
int writer_is_also_reader;
int new_reader_weight;
std::string comment="";
std::string domain_name="";
if (line.lookupValue("writer_hostgroup", writer_hostgroup)==false) {
proxy_error("Admin: detected a mysql_aws_aurora_hostgroups in config file without a mandatory writer_hostgroup\n");
continue;
}
if (line.lookupValue("reader_hostgroup", reader_hostgroup)==false) {
proxy_error("Admin: detected a mysql_aws_aurora_hostgroups in config file without a mandatory reader_hostgroup\n");
continue;
}
if (line.lookupValue("aurora_port", aurora_port)==false) aurora_port=3306;
if (line.lookupValue("max_lag_ms", max_lag_ms)==false) max_lag_ms=600000;
if (line.lookupValue("check_interval_ms", check_interval_ms)==false) check_interval_ms=1000;
if (line.lookupValue("check_timeout_ms", check_timeout_ms)==false) check_timeout_ms=1000;
if (line.lookupValue("writer_is_also_reader", writer_is_also_reader)==false) writer_is_also_reader=0;
if (line.lookupValue("new_reader_weight", new_reader_weight)==false) new_reader_weight=1;
if (line.lookupValue("add_lag_ms", add_lag_ms)==false) add_lag_ms=30;
if (line.lookupValue("min_lag_ms", min_lag_ms)==false) min_lag_ms=30;
if (line.lookupValue("lag_num_checks", lag_num_checks)==false) lag_num_checks=1;
line.lookupValue("comment", comment);
line.lookupValue("domain_name", domain_name);
char *o1=strdup(comment.c_str());
char *o=escape_string_single_quotes(o1, false);
char *p1=strdup(domain_name.c_str());
char *p=escape_string_single_quotes(p1, false);
char *query=(char *)malloc(strlen(q)+strlen(o)+strlen(p)+256); // 128 vs sizeof(int)*8
sprintf(query,q, writer_hostgroup, reader_hostgroup, active, aurora_port, p, max_lag_ms, check_interval_ms, check_timeout_ms, writer_is_also_reader, new_reader_weight, add_lag_ms, min_lag_ms, lag_num_checks, o);
//fprintf(stderr, "%s\n", query);
admindb->execute(query);
if (o!=o1) free(o);
free(o1);
if (p!=p1) free(p);
free(p1);
free(query);
rows++;
}
}
if (root.exists("mysql_hostgroup_attributes") == true) {
const Setting &mysql_hostgroup_attributes = root["mysql_hostgroup_attributes"];
int count = mysql_hostgroup_attributes.getLength();
for (i = 0; i < count; i++) {
const Setting &hostgroup_attributes = mysql_hostgroup_attributes[i];
bool is_first_field = true;
int integer_val = 0;
std::string string_val = "";
std::string fields = "";
std::string values = "";
auto process_field = [&](const std::string &field_name, const std::string &field_value, int is_int) {
if (!is_first_field) {
fields += ", ";
values += ", ";
}
else {
is_first_field = false;
}
fields += field_name;
if (is_int) {
values += field_value;
}
else {
char *cs = strdup(field_value.c_str());
char *ecs = escape_string_single_quotes(cs, false);
values += std::string("'") + ecs + "'";
if (cs != ecs) free(cs);
free(ecs);
}
};
// Only inserting/updating fields which are in configuration file.
// Fields default will be from table schema.
// Parsing integer field
if (hostgroup_attributes.lookupValue("hostgroup_id", integer_val) ) {
process_field("hostgroup_id", to_string(integer_val), true);
}
else {
proxy_error("Admin: detected a mysql_hostgroup_attributes in config file without a mandatory hostgroup_id.\n");
continue;
}
if (hostgroup_attributes.lookupValue("max_num_online_servers", integer_val)) {
process_field("max_num_online_servers", to_string(integer_val), true);
}
if (hostgroup_attributes.lookupValue("autocommit", integer_val)) {
process_field("autocommit", to_string(integer_val), true);
}
if (hostgroup_attributes.lookupValue("free_connections_pct", integer_val)) {
process_field("free_connections_pct", to_string(integer_val), true);
}
if (hostgroup_attributes.lookupValue("multiplex", integer_val)) {
process_field("multiplex", to_string(integer_val), true);
}
if (hostgroup_attributes.lookupValue("connection_warming", integer_val)) {
process_field("connection_warming", to_string(integer_val), true);
}
if (hostgroup_attributes.lookupValue("throttle_connections_per_sec", integer_val)) {
process_field("throttle_connections_per_sec", to_string(integer_val), true);
}
// Parsing string field
if (hostgroup_attributes.lookupValue("init_connect", string_val)) {
process_field("init_connect", string_val, false);
}
if (hostgroup_attributes.lookupValue("ignore_session_variables", string_val)) {
process_field("ignore_session_variables", string_val, false);
}
if (hostgroup_attributes.lookupValue("hostgroup_settings", string_val)) {
process_field("hostgroup_settings", string_val, false);
}
if (hostgroup_attributes.lookupValue("servers_defaults", string_val)) {
process_field("servers_defaults", string_val, false);
}
if (hostgroup_attributes.lookupValue("comment", string_val)) {
process_field("comment", string_val, false);
}
std::string s_query = "INSERT OR REPLACE INTO mysql_hostgroup_attributes (";
s_query += fields + ") VALUES (" + values + ")";
//fprintf(stderr, "%s\n", s_query.c_str());
if (admindb->execute(s_query.c_str()) == false) {
proxy_error("Admin: detected a mysql_hostgroup_attributes invalid value. Failed to insert in the table.\n");
continue;
}
rows++;
}
}
admindb->execute("PRAGMA foreign_keys = ON");
return rows;
}
int ProxySQL_Config::Write_ProxySQL_Servers_to_configfile(std::string& data) {
char* error = NULL;
int cols = 0;
int affected_rows = 0;
SQLite3_result* sqlite_resultset = NULL;
char *query=(char *)"SELECT * FROM proxysql_servers";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from proxysql_servers: %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
data += "proxysql_servers:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "hostname", r->fields[0]);
addField(data, "port", r->fields[1], "");
addField(data, "weight", r->fields[2], "");
addField(data, "comment", r->fields[3]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
return 0;
}
int ProxySQL_Config::Read_ProxySQL_Servers_from_configfile(std::string& error) {
const Setting& root = GloVars.confFile->cfg.getRoot();
int i;
int rows=0;
admindb->execute("PRAGMA foreign_keys = OFF");
if (root.exists("proxysql_servers")==true) {
const Setting & proxysql_servers = root["proxysql_servers"];
int count = proxysql_servers.getLength();
if (!validate_proxysql_servers(proxysql_servers, error)) {
proxy_error("Admin: %s\n", error.c_str());
return -1;
}
char *q=(char *)"INSERT OR REPLACE INTO proxysql_servers (hostname, port, weight, comment) VALUES (\"%s\", %d, %d, '%s')";
for (i=0; i< count; i++) {
const Setting &server = proxysql_servers[i];
std::string address;
int port;
int weight=0;
std::string comment="";
if (!server.lookupValue("address", address)) {
server.lookupValue("hostname", address);
}
server.lookupValue("port", port);
server.lookupValue("weight", weight);
server.lookupValue("comment", comment);
char *o1=strdup(comment.c_str());
char *o=escape_string_single_quotes(o1, false);
char *query=(char *)malloc(strlen(q)+strlen(address.c_str())+strlen(o)+128);
sprintf(query, q, address.c_str(), port, weight, o);
proxy_info("Cluster: Adding ProxySQL Servers %s:%d from config file\n", address.c_str(), port);
//fprintf(stderr, "%s\n", query);
admindb->execute(query);
if (o!=o1) free(o);
free(o1);
free(query);
rows++;
}
}
admindb->execute("PRAGMA foreign_keys = ON");
return rows;
}
int ProxySQL_Config::Write_Global_Variables_to_configfile(std::string& data) {
char* error = NULL;
int cols = 0;
int affected_rows = 0;
SQLite3_result* sqlite_resultset = NULL;
char *query=(char *)"SELECT variable_name, variable_value FROM global_variables ORDER BY variable_name";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from global_variables : %s\n", error);
return -1;
} else {
if (sqlite_resultset) {
std::string prefix;
for (auto r : sqlite_resultset->rows) {
std::string input(r->fields[0]);
std::string p1 = input.substr(0, input.find("-"));
if (prefix.empty()) {
prefix = input.substr(0, input.find("-"));
data += prefix + "_variables =\n{\n";
} else {
if (p1.compare(prefix)) {
prefix = p1;
data += "}\n\n" + prefix + "_variables = \n{\n";
}
}
if (r->fields[1] && strlen(r->fields[1])) {
std::stringstream ss;
ss << "\t" << r->fields[0] + p1.size() + 1 << "=\"" << r->fields[1] << "\"\n";
data += ss.str();
}
}
if (!prefix.empty())
data += "}\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
return 0;
}
int ProxySQL_Config::Write_PgSQL_Servers_to_configfile(std::string& data) {
char* error = NULL;
int cols = 0;
int affected_rows = 0;
SQLite3_result* sqlite_resultset = NULL;
char* query = (char*)"SELECT * FROM pgsql_servers";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from pgsql_servers : %s\n", error);
return -1;
}
else {
if (sqlite_resultset) {
data += "pgsql_servers:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "hostgroup_id", r->fields[0], "");
addField(data, "hostname", r->fields[1]);
addField(data, "port", r->fields[2], "");
addField(data, "status", r->fields[3]);
addField(data, "weight", r->fields[4], "");
addField(data, "compression", r->fields[5], "");
addField(data, "max_connections", r->fields[6], "");
addField(data, "max_replication_lag", r->fields[7], "");
addField(data, "use_ssl", r->fields[8], "");
addField(data, "max_latency_ms", r->fields[9], "");
addField(data, "comment", r->fields[10]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
query = (char*)"SELECT * FROM pgsql_replication_hostgroups";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from pgsql_replication_hostgroups : %s\n", error);
return -1;
}
else {
if (sqlite_resultset) {
data += "pgsql_replication_hostgroups:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "writer_hostgroup", r->fields[0], "");
addField(data, "reader_hostgroup", r->fields[1], "");
addField(data, "check_type", r->fields[2]);
addField(data, "comment", r->fields[3]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
return 0;
}
int ProxySQL_Config::Read_PgSQL_Servers_from_configfile(std::string& error) {
const Setting& root = GloVars.confFile->cfg.getRoot();
int i;
int rows = 0;
admindb->execute("PRAGMA foreign_keys = OFF");
if (root.exists("pgsql_servers") == true) {
const Setting& pgsql_servers = root["pgsql_servers"];
int count = pgsql_servers.getLength();
if (!validate_backend_servers(PROXYSQL_CONFIG_PGSQL_SERVERS, pgsql_servers, error)) {
proxy_error("Admin: %s\n", error.c_str());
return -1;
}
char* q = (char*)"INSERT OR REPLACE INTO pgsql_servers (hostname, port, hostgroup_id, compression, weight, status, max_connections, max_replication_lag, use_ssl, max_latency_ms, comment) VALUES (\"%s\", %d, %d, %d, %d, \"%s\", %d, %d, %d, %d, '%s')";
for (i = 0; i < count; i++) {
const Setting& server = pgsql_servers[i];
std::string address;
std::string status = "ONLINE";
int port = 5432;
int hostgroup;
int weight = 1;
int compression = 0;
int max_connections = 1000; // default
int max_replication_lag = 0; // default
int use_ssl = 0;
int max_latency_ms = 0;
std::string comment = "";
if (!server.lookupValue("address", address)) {
server.lookupValue("hostname", address);
}
if (!server.lookupValue("hostgroup", hostgroup)) {
server.lookupValue("hostgroup_id", hostgroup);
}
server.lookupValue("port", port);
server.lookupValue("status", status);
if (
(strcasecmp(status.c_str(), (char*)"ONLINE"))
&& (strcasecmp(status.c_str(), (char*)"SHUNNED"))
&& (strcasecmp(status.c_str(), (char*)"OFFLINE_SOFT"))
&& (strcasecmp(status.c_str(), (char*)"OFFLINE_HARD"))
) {
status = "ONLINE";
}
server.lookupValue("compression", compression);
server.lookupValue("weight", weight);
server.lookupValue("max_connections", max_connections);
server.lookupValue("max_replication_lag", max_replication_lag);
server.lookupValue("use_ssl", use_ssl);
server.lookupValue("max_latency_ms", max_latency_ms);
server.lookupValue("comment", comment);
char* o1 = strdup(comment.c_str());
char* o = escape_string_single_quotes(o1, false);
char* query = (char*)malloc(strlen(q) + strlen(status.c_str()) + strlen(address.c_str()) + strlen(o) + 128);
sprintf(query, q, address.c_str(), port, hostgroup, compression, weight, status.c_str(), max_connections, max_replication_lag, use_ssl, max_latency_ms, o);
//fprintf(stderr, "%s\n", query);
admindb->execute(query);
if (o != o1) free(o);
free(o1);
free(query);
rows++;
}
}
// TODO: Add validation to pgsql_replication_hostgroups similar to pgsql_servers
if (root.exists("pgsql_replication_hostgroups") == true) {
const Setting& pgsql_replication_hostgroups = root["pgsql_replication_hostgroups"];
int count = pgsql_replication_hostgroups.getLength();
char* q = (char*)"INSERT OR REPLACE INTO pgsql_replication_hostgroups (writer_hostgroup, reader_hostgroup, comment, check_type) VALUES (%d, %d, '%s', '%s')";
for (i = 0; i < count; i++) {
const Setting& line = pgsql_replication_hostgroups[i];
int writer_hostgroup;
int reader_hostgroup;
std::string comment = "";
std::string check_type = "";
if (line.lookupValue("writer_hostgroup", writer_hostgroup) == false) {
proxy_error("Admin: detected a pgsql_replication_hostgroups in config file without a mandatory writer_hostgroup\n");
continue;
}
if (line.lookupValue("reader_hostgroup", reader_hostgroup) == false) {
proxy_error("Admin: detected a pgsql_replication_hostgroups in config file without a mandatory reader_hostgroup\n");
continue;
}
line.lookupValue("comment", comment);
char* o1 = strdup(comment.c_str());
char* o = escape_string_single_quotes(o1, false);
line.lookupValue("check_type", check_type);
if (
(strcasecmp(check_type.c_str(), (char*)"read_only"))
&& (strcasecmp(check_type.c_str(), (char*)"innodb_read_only"))
&& (strcasecmp(check_type.c_str(), (char*)"super_read_only"))
) {
check_type = "read_only";
}
char* t1 = strdup(check_type.c_str());
char* t = escape_string_single_quotes(t1, false);
char* query = (char*)malloc(strlen(q) + strlen(o) + strlen(t) + 32);
sprintf(query, q, writer_hostgroup, reader_hostgroup, o, t);
//fprintf(stderr, "%s\n", query);
admindb->execute(query);
if (o != o1) free(o);
free(o1);
if (t != t1) free(t);
free(t1);
free(query);
rows++;
}
}
admindb->execute("PRAGMA foreign_keys = ON");
return rows;
}
int ProxySQL_Config::Write_PgSQL_Users_to_configfile(std::string& data) {
char* error = NULL;
int cols = 0;
int affected_rows = 0;
SQLite3_result* sqlite_resultset = NULL;
char* query = (char*)"SELECT * FROM pgsql_users";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from pgsql_users: %s\n", error);
return -1;
}
else {
if (sqlite_resultset) {
data += "pgsql_users:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "username", r->fields[0]);
addField(data, "password", r->fields[1]);
addField(data, "active", r->fields[2], "");
addField(data, "use_ssl", r->fields[3], "");
addField(data, "default_hostgroup", r->fields[4], "");
addField(data, "transaction_persistent", r->fields[5], "");
addField(data, "fast_forward", r->fields[6], "");
addField(data, "backend", r->fields[7], "");
addField(data, "frontend", r->fields[8], "");
addField(data, "max_connections", r->fields[9], "");
addField(data, "attributes", r->fields[10]);
addField(data, "comment", r->fields[11]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
return 0;
}
int ProxySQL_Config::Read_PgSQL_Users_from_configfile(std::string& error) {
const Setting& root = GloVars.confFile->cfg.getRoot();
if (root.exists("pgsql_users") == false) return 0;
const Setting& pgsql_users = root["pgsql_users"];
int count = pgsql_users.getLength();
if (!validate_backend_users(PROXYSQL_CONFIG_PGSQL_USERS, pgsql_users, error)) {
proxy_error("Admin: %s\n", error.c_str());
return -1;
}
int rows = 0;
admindb->execute("PRAGMA foreign_keys = OFF");
char* q = (char*)"INSERT OR REPLACE INTO pgsql_users (username, password, active, use_ssl, default_hostgroup, transaction_persistent, fast_forward, max_connections, attributes, comment) VALUES ('%s', '%s', %d, %d, %d, %d, %d, %d, '%s','%s')";
for (int i = 0; i < count; i++) {
const Setting& user = pgsql_users[i];
std::string username;
std::string password = "";
int active = 1;
int use_ssl = 0;
int default_hostgroup = 0;
int transaction_persistent = 1;
int fast_forward = 0;
int max_connections = 10000;
std::string comment = "";
std::string attributes = "";
user.lookupValue("username", username);
user.lookupValue("password", password);
user.lookupValue("default_hostgroup", default_hostgroup);
user.lookupValue("active", active);
user.lookupValue("use_ssl", use_ssl);
//if (user.lookupValue("default_schema", default_schema)==false) default_schema="";
user.lookupValue("transaction_persistent", transaction_persistent);
user.lookupValue("fast_forward", fast_forward);
user.lookupValue("max_connections", max_connections);
user.lookupValue("attributes", attributes);
user.lookupValue("comment", comment);
char* o1 = strdup(comment.c_str());
char* o = escape_string_single_quotes(o1, false);
char* query = (char*)malloc(strlen(q) + strlen(username.c_str()) + strlen(password.c_str()) + strlen(o) + strlen(attributes.c_str()) + 128);
sprintf(query, q, username.c_str(), password.c_str(), active, use_ssl, default_hostgroup, transaction_persistent, fast_forward, max_connections, attributes.c_str(), o);
admindb->execute(query);
if (o != o1) free(o);
free(o1);
free(query);
rows++;
}
admindb->execute("PRAGMA foreign_keys = ON");
return rows;
}
int ProxySQL_Config::Write_PgSQL_Query_Rules_to_configfile(std::string& data) {
char* error = NULL;
int cols = 0;
int affected_rows = 0;
SQLite3_result* sqlite_resultset = NULL;
char* query = (char*)"SELECT * FROM pgsql_query_rules";
admindb->execute_statement(query, &error, &cols, &affected_rows, &sqlite_resultset);
if (error) {
proxy_error("Error on read from pgsql_query_rules : %s\n", error);
return -1;
}
else {
if (sqlite_resultset) {
std::string prefix;
data += "pgsql_query_rules:\n(\n";
bool isNext = false;
for (auto r : sqlite_resultset->rows) {
if (isNext)
data += ",\n";
data += "\t{\n";
addField(data, "rule_id", r->fields[0], "");
addField(data, "active", r->fields[1], "");
addField(data, "username", r->fields[2]);
addField(data, "database", r->fields[3]);
addField(data, "flagIN", r->fields[4], "");
addField(data, "client_addr", r->fields[5]);
addField(data, "proxy_addr", r->fields[6]);
addField(data, "proxy_port", r->fields[7], "");
addField(data, "digest", r->fields[8]);
addField(data, "match_digest", r->fields[9]);
addField(data, "match_pattern", r->fields[10]);
addField(data, "negate_match_pattern", r->fields[11], "");
addField(data, "re_modifiers", r->fields[12]);
addField(data, "flagOUT", r->fields[13], "");
addField(data, "replace_pattern", r->fields[14]);
addField(data, "destination_hostgroup", r->fields[15], "");
addField(data, "cache_ttl", r->fields[16], "");
addField(data, "cache_empty_result", r->fields[17], "");
addField(data, "cache_timeout", r->fields[18], "");
addField(data, "reconnect", r->fields[19], "");
addField(data, "timeout", r->fields[20], "");
addField(data, "retries", r->fields[21], "");
addField(data, "delay", r->fields[22], "");
addField(data, "next_query_flagIN", r->fields[23], "");
addField(data, "mirror_flagOUT", r->fields[24], "");
addField(data, "mirror_hostgroup", r->fields[25], "");
addField(data, "error_msg", r->fields[26]);
addField(data, "OK_msg", r->fields[27]);
addField(data, "sticky_conn", r->fields[28], "");
addField(data, "multiplex", r->fields[29], "");
addField(data, "log", r->fields[30], "");
addField(data, "apply", r->fields[31], "");
addField(data, "attributes", r->fields[32]);
addField(data, "comment", r->fields[33]);
data += "\t}";
isNext = true;
}
data += "\n)\n";
}
}
if (sqlite_resultset)
delete sqlite_resultset;
return 0;
}
int ProxySQL_Config::Read_PgSQL_Query_Rules_from_configfile() {
const Setting& root = GloVars.confFile->cfg.getRoot();
if (root.exists("pgsql_query_rules") == false) return 0;
const Setting& pgsql_query_rules = root["pgsql_query_rules"];
int count = pgsql_query_rules.getLength();
//fprintf(stderr, "Found %d users\n",count);
int i;
int rows = 0;
admindb->execute("PRAGMA foreign_keys = OFF");
char* q = (char*)"INSERT OR REPLACE INTO pgsql_query_rules (rule_id, active, username, database, flagIN, client_addr, proxy_addr, proxy_port, digest, match_digest, match_pattern, negate_match_pattern, re_modifiers, flagOUT, replace_pattern, destination_hostgroup, cache_ttl, cache_empty_result, cache_timeout, reconnect, timeout, retries, delay, next_query_flagIN, mirror_flagOUT, mirror_hostgroup, error_msg, ok_msg, sticky_conn, multiplex, log, apply, attributes, comment) VALUES (%d, %d, %s, %s, %s, %s, %s, %s, %s, %s, %s, %d, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %d, %s, %s)";
for (i = 0; i < count; i++) {
const Setting& rule = pgsql_query_rules[i];
int rule_id;
int active = 1;
bool username_exists = false;
std::string username;
bool database_exists = false;
std::string database;
int flagIN = 0;
// variables for parsing client_addr
bool client_addr_exists = false;
std::string client_addr;
// variables for parsing proxy_addr
bool proxy_addr_exists = false;
std::string proxy_addr;
// variable for parsing proxy_port
int proxy_port = -1;
// variables for parsing digest
bool digest_exists = false;
std::string digest;
bool match_digest_exists = false;
std::string match_digest;
bool match_pattern_exists = false;
std::string match_pattern;
int negate_match_pattern = 0;
bool re_modifiers_exists = false;
std::string re_modifiers;
int flagOUT = -1;
bool replace_pattern_exists = false;
std::string replace_pattern;
int destination_hostgroup = -1;
int next_query_flagIN = -1;
int mirror_flagOUT = -1;
int mirror_hostgroup = -1;
int cache_ttl = -1;
int cache_empty_result = -1;
int cache_timeout = -1;
int reconnect = -1;
int timeout = -1;
int retries = -1;
int delay = -1;
bool error_msg_exists = false;
std::string error_msg;
bool OK_msg_exists = false;
std::string OK_msg;
int sticky_conn = -1;
int multiplex = -1;
// variable for parsing log
int log = -1;
int apply = 0;
// attributes
bool attributes_exists = false;
std::string attributes{};
bool comment_exists = false;
std::string comment;
// validate arguments
if (rule.lookupValue("rule_id", rule_id) == false) {
proxy_error("Admin: detected a pgsql_query_rules in config file without a mandatory rule_id\n");
continue;
}
rule.lookupValue("active", active);
if (rule.lookupValue("username", username)) username_exists = true;
if (rule.lookupValue("database", database)) database_exists = true;
rule.lookupValue("flagIN", flagIN);
if (rule.lookupValue("client_addr", client_addr)) client_addr_exists = true;
if (rule.lookupValue("proxy_addr", proxy_addr)) proxy_addr_exists = true;
rule.lookupValue("proxy_port", proxy_port);
if (rule.lookupValue("digest", digest)) digest_exists = true;
if (rule.lookupValue("match_digest", match_digest)) match_digest_exists = true;
if (rule.lookupValue("match_pattern", match_pattern)) match_pattern_exists = true;
rule.lookupValue("negate_match_pattern", negate_match_pattern);
if (rule.lookupValue("re_modifiers", re_modifiers)) {
}
else {
re_modifiers = "CASELESS";
}
re_modifiers_exists = true;
rule.lookupValue("flagOUT", flagOUT);
if (rule.lookupValue("replace_pattern", replace_pattern)) replace_pattern_exists = true;
rule.lookupValue("destination_hostgroup", destination_hostgroup);
rule.lookupValue("next_query_flagIN", next_query_flagIN);
rule.lookupValue("mirror_flagOUT", mirror_flagOUT);
rule.lookupValue("mirror_hostgroup", mirror_hostgroup);
rule.lookupValue("cache_ttl", cache_ttl);
rule.lookupValue("cache_empty_result", cache_empty_result);
rule.lookupValue("cache_timeout", cache_timeout);
rule.lookupValue("reconnect", reconnect);
rule.lookupValue("timeout", timeout);
rule.lookupValue("retries", retries);
rule.lookupValue("delay", delay);
if (rule.lookupValue("error_msg", error_msg)) error_msg_exists = true;
if (rule.lookupValue("OK_msg", OK_msg)) OK_msg_exists = true;
rule.lookupValue("sticky_conn", sticky_conn);
rule.lookupValue("multiplex", multiplex);
rule.lookupValue("log", log);
rule.lookupValue("apply", apply);
if (rule.lookupValue("comment", comment)) comment_exists = true;
if (rule.lookupValue("attributes", attributes)) attributes_exists = true;
//if (user.lookupValue("default_schema", default_schema)==false) default_schema="";
int query_len = 0;
query_len += strlen(q) +
strlen(std::to_string(rule_id).c_str()) +
strlen(std::to_string(active).c_str()) +
(username_exists ? strlen(username.c_str()) : 0) + 4 +
(database_exists ? strlen(database.c_str()) : 0) + 4 +
strlen(std::to_string(flagIN).c_str()) + 4 +
(client_addr_exists ? strlen(client_addr.c_str()) : 0) + 4 +
(proxy_addr_exists ? strlen(proxy_addr.c_str()) : 0) + 4 +
strlen(std::to_string(proxy_port).c_str()) + 4 +
(match_digest_exists ? strlen(match_digest.c_str()) : 0) + 4 +
(match_pattern_exists ? strlen(match_pattern.c_str()) : 0) + 4 +
strlen(std::to_string(negate_match_pattern).c_str()) + 4 +
(re_modifiers_exists ? strlen(re_modifiers.c_str()) : 0) + 4 +
strlen(std::to_string(flagOUT).c_str()) + 4 +
(replace_pattern_exists ? strlen(replace_pattern.c_str()) : 0) + 4 +
strlen(std::to_string(destination_hostgroup).c_str()) + 4 +
strlen(std::to_string(cache_ttl).c_str()) + 4 +
strlen(std::to_string(cache_empty_result).c_str()) + 4 +
strlen(std::to_string(cache_timeout).c_str()) + 4 +
strlen(std::to_string(reconnect).c_str()) + 4 +
strlen(std::to_string(timeout).c_str()) + 4 +
strlen(std::to_string(next_query_flagIN).c_str()) + 4 +
strlen(std::to_string(mirror_flagOUT).c_str()) + 4 +
strlen(std::to_string(mirror_hostgroup).c_str()) + 4 +
strlen(std::to_string(retries).c_str()) + 4 +
strlen(std::to_string(delay).c_str()) + 4 +
(error_msg_exists ? strlen(error_msg.c_str()) : 0) + 4 +
(OK_msg_exists ? strlen(OK_msg.c_str()) : 0) + 4 +
strlen(std::to_string(sticky_conn).c_str()) + 4 +
strlen(std::to_string(multiplex).c_str()) + 4 +
strlen(std::to_string(log).c_str()) + 4 +
strlen(std::to_string(apply).c_str()) + 4 +
(attributes_exists ? strlen(attributes.c_str()) : 0) + 4 +
(comment_exists ? strlen(comment.c_str()) : 0) + 4 +
64;
char* query = (char*)malloc(query_len);
if (username_exists)
username = "\"" + username + "\"";
else
username = "NULL";
if (database_exists)
database = "\"" + database + "\"";
else
database = "NULL";
if (client_addr_exists)
client_addr = "\"" + client_addr + "\"";
else
client_addr = "NULL";
if (proxy_addr_exists)
proxy_addr = "\"" + proxy_addr + "\"";
else
proxy_addr = "NULL";
if (digest_exists)
digest = "\"" + digest + "\"";
else
digest = "NULL";
if (match_digest_exists)
match_digest = "\"" + match_digest + "\"";
else
match_digest = "NULL";
if (match_pattern_exists)
match_pattern = "\"" + match_pattern + "\"";
else
match_pattern = "NULL";
if (replace_pattern_exists)
replace_pattern = "\"" + replace_pattern + "\"";
else
replace_pattern = "NULL";
if (error_msg_exists)
error_msg = "\"" + error_msg + "\"";
else
error_msg = "NULL";
if (OK_msg_exists)
OK_msg = "\"" + OK_msg + "\"";
else
OK_msg = "NULL";
if (re_modifiers_exists)
re_modifiers = "\"" + re_modifiers + "\"";
else
re_modifiers = "NULL";
if (attributes_exists)
attributes = "'" + attributes + "'";
else
attributes = "NULL";
if (comment_exists)
comment = "'" + comment + "'";
else
comment = "NULL";
sprintf(query, q,
rule_id, active,
username.c_str(),
database.c_str(),
(flagIN >= 0 ? std::to_string(flagIN).c_str() : "NULL"),
client_addr.c_str(),
proxy_addr.c_str(),
(proxy_port >= 0 ? std::to_string(proxy_port).c_str() : "NULL"),
digest.c_str(),
match_digest.c_str(),
match_pattern.c_str(),
(negate_match_pattern == 0 ? 0 : 1),
re_modifiers.c_str(),
(flagOUT >= 0 ? std::to_string(flagOUT).c_str() : "NULL"),
replace_pattern.c_str(),
(destination_hostgroup >= 0 ? std::to_string(destination_hostgroup).c_str() : "NULL"),
(cache_ttl >= 0 ? std::to_string(cache_ttl).c_str() : "NULL"),
(cache_empty_result >= 0 ? std::to_string(cache_empty_result).c_str() : "NULL"),
(cache_timeout >= 0 ? std::to_string(cache_timeout).c_str() : "NULL"),
(reconnect >= 0 ? std::to_string(reconnect).c_str() : "NULL"),
(timeout >= 0 ? std::to_string(timeout).c_str() : "NULL"),
(retries >= 0 ? std::to_string(retries).c_str() : "NULL"),
(delay >= 0 ? std::to_string(delay).c_str() : "NULL"),
(next_query_flagIN >= 0 ? std::to_string(next_query_flagIN).c_str() : "NULL"),
(mirror_flagOUT >= 0 ? std::to_string(mirror_flagOUT).c_str() : "NULL"),
(mirror_hostgroup >= 0 ? std::to_string(mirror_hostgroup).c_str() : "NULL"),
error_msg.c_str(),
OK_msg.c_str(),
(sticky_conn >= 0 ? std::to_string(sticky_conn).c_str() : "NULL"),
(multiplex >= 0 ? std::to_string(multiplex).c_str() : "NULL"),
(log >= 0 ? std::to_string(log).c_str() : "NULL"),
(apply == 0 ? 0 : 1),
attributes.c_str(),
comment.c_str()
);
//fprintf(stderr, "%s\n", query);
admindb->execute(query);
free(query);
rows++;
}
admindb->execute("PRAGMA foreign_keys = ON");
return rows;
}
bool ProxySQL_Config::validate_backend_users(proxysql_config_type type, const Setting& config, std::string& error) {
std::set<std::tuple<std::string, int>> pk_set;
int count = config.getLength();
for (int i = 0; i < count; i++) {
const Setting& user = config[i];
std::string config;
std::string username;
int backend = 1; // default backend value
config = (type == PROXYSQL_CONFIG_MYSQL_USERS) ? "mysql_users" : "pgsql_users";
if (user.lookupValue("username", username) == false) {
error = "mandatory field username missing from a " + config + " entry in config file";
return false;
}
user.lookupValue("backend", backend);
auto key = std::make_tuple(username, backend);
if (pk_set.find(key) != pk_set.end()) {
error = "duplicate entries found in " + config + " in config file";
return false;
}
pk_set.insert(key);
}
return true;
}
bool ProxySQL_Config::validate_backend_servers(proxysql_config_type type, const Setting& config, std::string& error) {
std::set<std::tuple<int, std::string, int>> pk_set;
int count = config.getLength();
for (int i = 0; i < count; i++) {
const Setting& server = config[i];
std::string config;
std::string address;
int port;
int hostgroup;
config = (type == PROXYSQL_CONFIG_MYSQL_SERVERS) ? "mysql_servers" : "pgsql_servers";
port = (type == PROXYSQL_CONFIG_MYSQL_SERVERS) ? 3306 : 5432;
if (server.lookupValue("hostgroup", hostgroup) == false) {
if (server.lookupValue("hostgroup_id", hostgroup) == false) {
error = "mandatory field hostgroup_id missing from a " + config + " entry in config file";
return false;
}
}
if (server.lookupValue("address", address) == false) {
if (server.lookupValue("hostname", address) == false) {
error = "mandatory field hostname missing from a " + config + " entry in config file";
return false;
}
}
server.lookupValue("port", port);
auto key = std::make_tuple(hostgroup, address, port);
if (pk_set.find(key) != pk_set.end()) {
error = "duplicate entries found in " + config + " in config file";
return false;
}
pk_set.insert(key);
}
return true;
}
bool ProxySQL_Config::validate_proxysql_servers(const Setting& config, std::string& error) {
std::set<std::tuple<std::string, int>> pk_set;
int count = config.getLength();
for (int i = 0; i < count; i++) {
const Setting& server = config[i];
std::string address;
int port;
if (server.lookupValue("address", address) == false) {
if (server.lookupValue("hostname", address) == false) {
error = "mandatory field hostname missing from a proxysql_servers entry in config file";
return false;
}
}
if (server.lookupValue("port", port) == false) {
error = "mandatory field port missing from a proxysql_servers entry in config file";
return false;
}
auto key = std::make_tuple(address, port);
if (pk_set.find(key) != pk_set.end()) {
error = "duplicate entries found in proxysql_servers in config file";
return false;
}
pk_set.insert(key);
}
return true;
}
Reference in new issue View Git Blame Copy Permalink