Skip to content

Commit cdfcfdc

Browse files
renecannaorenecannao
authored
Merge pull request #4528 from sysown/v2.x_monitor_slave_lag_when_null_4521
Introduced new HG attribute 'monitor_slave_lag_when_null' which takes precedence over 'mysql_thread_monitor_slave_lag_when_null'
2 parents 4f419e6 + 88af1f1 commit cdfcfdc

7 files changed

+69
-49
lines changed

‎include/MySQL_HostGroups_Manager.h

+9-2
Original file line numberDiff line numberDiff line change
@@ -297,6 +297,7 @@ class MyHGC { // MySQL Host Group Container
297297
char * ignore_session_variables_text; // this is the original version (text format) of ignore_session_variables
298298
uint32_t max_num_online_servers;
299299
uint32_t throttle_connections_per_sec;
300+
int32_t monitor_slave_lag_when_null;
300301
int8_t autocommit;
301302
int8_t free_connections_pct;
302303
int8_t handle_warnings;
@@ -316,6 +317,10 @@ class MyHGC { // MySQL Host Group Container
316317
bool handle_warnings_enabled() const {
317318
return attributes.configured == true && attributes.handle_warnings != -1 ? attributes.handle_warnings : mysql_thread___handle_warnings;
318319
}
320+
inline
321+
int32_t get_monitor_slave_lag_when_null() const {
322+
return attributes.configured == true && attributes.monitor_slave_lag_when_null != -1 ? attributes.monitor_slave_lag_when_null : mysql_thread___monitor_slave_lag_when_null;
323+
}
319324
MyHGC(int);
320325
~MyHGC();
321326
MySrvC *get_random_MySrvC(char * gtid_uuid, uint64_t gtid_trxid, int max_lag_ms, MySQL_Session *sess);
@@ -549,9 +554,10 @@ using address_t = std::string;
549554
using port_t = unsigned int;
550555
using read_only_t = int;
551556
using current_replication_lag = int;
557+
using override_replication_lag = bool;
552558

553559
using read_only_server_t = std::tuple<hostname_t,port_t,read_only_t>;
554-
using replication_lag_server_t = std::tuple<hostgroupid_t,address_t,port_t,current_replication_lag>;
560+
using replication_lag_server_t = std::tuple<hostgroupid_t,address_t,port_t,current_replication_lag,override_replication_lag>;
555561

556562
enum READ_ONLY_SERVER_T {
557563
ROS_HOSTNAME = 0,
@@ -565,6 +571,7 @@ enum REPLICATION_LAG_SERVER_T {
565571
RLS_ADDRESS,
566572
RLS_PORT,
567573
RLS_CURRENT_REPLICATION_LAG,
574+
RLS_OVERRIDE_REPLICATION_LAG,
568575
RLS__SIZE
569576
};
570577

@@ -1101,7 +1108,7 @@ class MySQL_HostGroups_Manager {
11011108
void push_MyConn_to_pool_array(MySQL_Connection **, unsigned int);
11021109
void destroy_MyConn_from_pool(MySQL_Connection *, bool _lock=true);
11031110

1104-
void replication_lag_action_inner(MyHGC *, const char*, unsigned int, int);
1111+
void replication_lag_action_inner(MyHGC *, const char*, unsigned int, int, bool);
11051112
void replication_lag_action(const std::list<replication_lag_server_t>& mysql_servers);
11061113
void read_only_action(char *hostname, int port, int read_only);
11071114
void read_only_action_v2(const std::list<read_only_server_t>& mysql_servers);

‎include/SQLite3_Server.h

+2-2
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,7 @@ class SQLite3_Server {
5656
std::vector<table_def_t *> *tables_defs_readonly;
5757
#endif // TEST_READONLY
5858
#ifdef TEST_REPLICATIONLAG
59-
std::unordered_map<std::string, int> replicationlag_map;
59+
std::unordered_map<std::string, std::unique_ptr<int>> replicationlag_map;
6060
std::vector<table_def_t*>* tables_defs_replicationlag;
6161
#endif // TEST_REPLICATIONLAG
6262
#if defined(TEST_AURORA) || defined(TEST_GALERA) || defined(TEST_GROUPREP) || defined(TEST_READONLY) || defined(TEST_REPLICATIONLAG)
@@ -105,7 +105,7 @@ class SQLite3_Server {
105105
#ifdef TEST_REPLICATIONLAG
106106
pthread_mutex_t test_replicationlag_mutex;
107107
void load_replicationlag_table(MySQL_Session* sess);
108-
int replicationlag_test_value(const char* p);
108+
int* replicationlag_test_value(const char* p);
109109
int replicationlag_map_size() {
110110
return replicationlag_map.size();
111111
}

‎lib/MyHGC.cpp

+1
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,7 @@ void MyHGC::reset_attributes() {
3535
attributes.autocommit = -1;
3636
attributes.free_connections_pct = 10;
3737
attributes.handle_warnings = -1;
38+
attributes.monitor_slave_lag_when_null = -1;
3839
attributes.multiplex = true;
3940
attributes.connection_warming = false;
4041
free(attributes.init_connect);

‎lib/MySQL_HostGroups_Manager.cpp

+24-10
Original file line numberDiff line numberDiff line change
@@ -2692,9 +2692,16 @@ void MySQL_HostGroups_Manager::add(MySrvC *mysrvc, unsigned int _hid) {
26922692
myhgc->mysrvs->add(mysrvc);
26932693
}
26942694

2695-
void MySQL_HostGroups_Manager::replication_lag_action_inner(MyHGC *myhgc, const char *address, unsigned int port, int current_replication_lag) {
2696-
int j;
2697-
for (j=0; j<(int)myhgc->mysrvs->cnt(); j++) {
2695+
void MySQL_HostGroups_Manager::replication_lag_action_inner(MyHGC *myhgc, const char *address, unsigned int port,
2696+
int current_replication_lag, bool override_repl_lag) {
2697+
2698+
if (current_replication_lag == -1 && override_repl_lag == true) {
2699+
current_replication_lag = myhgc->get_monitor_slave_lag_when_null();
2700+
override_repl_lag = false;
2701+
proxy_error("Replication lag on server %s:%d is NULL, using value %d\n", address, port, current_replication_lag);
2702+
}
2703+
2704+
for (int j=0; j<(int)myhgc->mysrvs->cnt(); j++) {
26982705
MySrvC *mysrvc=(MySrvC *)myhgc->mysrvs->servers->index(j);
26992706
if (strcmp(mysrvc->address,address)==0 && mysrvc->port==port) {
27002707
mysrvc->cur_replication_lag = current_replication_lag;
@@ -2703,9 +2710,9 @@ void MySQL_HostGroups_Manager::replication_lag_action_inner(MyHGC *myhgc, const
27032710
// (current_replication_lag==-1 )
27042711
// ||
27052712
(
2706-
current_replication_lag>=0 &&
2713+
current_replication_lag >= 0 &&
27072714
mysrvc->max_replication_lag > 0 && // see issue #4018
2708-
((unsigned int)current_replication_lag > mysrvc->max_replication_lag)
2715+
(current_replication_lag > (int)mysrvc->max_replication_lag)
27092716
)
27102717
) {
27112718
// always increase the counter
@@ -2730,9 +2737,10 @@ void MySQL_HostGroups_Manager::replication_lag_action_inner(MyHGC *myhgc, const
27302737
} else {
27312738
if (mysrvc->get_status() == MYSQL_SERVER_STATUS_SHUNNED_REPLICATION_LAG) {
27322739
if (
2733-
(current_replication_lag>=0 && ((unsigned int)current_replication_lag <= mysrvc->max_replication_lag))
2740+
(/*current_replication_lag >= 0 &&*/override_repl_lag == false &&
2741+
(current_replication_lag <= (int)mysrvc->max_replication_lag))
27342742
||
2735-
(current_replication_lag==-2) // see issue 959
2743+
(current_replication_lag==-2 && override_repl_lag == true) // see issue 959
27362744
) {
27372745
mysrvc->set_status(MYSQL_SERVER_STATUS_ONLINE);
27382746
proxy_warning("Re-enabling server %s:%d from HG %u with replication lag of %d second\n", address, port, myhgc->hid, current_replication_lag);
@@ -2758,18 +2766,19 @@ void MySQL_HostGroups_Manager::replication_lag_action(const std::list<replicatio
27582766
const std::string& address = std::get<REPLICATION_LAG_SERVER_T::RLS_ADDRESS>(server);
27592767
const unsigned int port = std::get<REPLICATION_LAG_SERVER_T::RLS_PORT>(server);
27602768
const int current_replication_lag = std::get<REPLICATION_LAG_SERVER_T::RLS_CURRENT_REPLICATION_LAG>(server);
2769+
const bool override_repl_lag = std::get<REPLICATION_LAG_SERVER_T::RLS_OVERRIDE_REPLICATION_LAG>(server);
27612770

27622771
if (mysql_thread___monitor_replication_lag_group_by_host == false) {
27632772
// legacy check. 1 check per server per hostgroup
27642773
MyHGC *myhgc = MyHGC_find(hid);
2765-
replication_lag_action_inner(myhgc,address.c_str(),port,current_replication_lag);
2774+
replication_lag_action_inner(myhgc,address.c_str(),port,current_replication_lag,override_repl_lag);
27662775
}
27672776
else {
27682777
// only 1 check per server, no matter the hostgroup
27692778
// all hostgroups must be searched
27702779
for (unsigned int i=0; i<MyHostGroups->len; i++) {
27712780
MyHGC*myhgc=(MyHGC*)MyHostGroups->index(i);
2772-
replication_lag_action_inner(myhgc,address.c_str(),port,current_replication_lag);
2781+
replication_lag_action_inner(myhgc,address.c_str(),port,current_replication_lag,override_repl_lag);
27732782
}
27742783
}
27752784
}
@@ -6226,8 +6235,13 @@ void init_myhgc_hostgroup_settings(const char* hostgroup_settings, MyHGC* myhgc)
62266235
nlohmann::json j = nlohmann::json::parse(hostgroup_settings);
62276236

62286237
const auto handle_warnings_check = [](int8_t handle_warnings) -> bool { return handle_warnings == 0 || handle_warnings == 1; };
6229-
int8_t handle_warnings = j_get_srv_default_int_val<int8_t>(j, hid, "handle_warnings", handle_warnings_check);
6238+
const int8_t handle_warnings = j_get_srv_default_int_val<int8_t>(j, hid, "handle_warnings", handle_warnings_check);
62306239
myhgc->attributes.handle_warnings = handle_warnings;
6240+
6241+
const auto monitor_slave_lag_when_null_check = [](int32_t monitor_slave_lag_when_null) -> bool
6242+
{ return (monitor_slave_lag_when_null >= 0 && monitor_slave_lag_when_null <= 604800); };
6243+
const int32_t monitor_slave_lag_when_null = j_get_srv_default_int_val<int32_t>(j, hid, "monitor_slave_lag_when_null", monitor_slave_lag_when_null_check);
6244+
myhgc->attributes.monitor_slave_lag_when_null = monitor_slave_lag_when_null;
62316245
}
62326246
catch (const json::exception& e) {
62336247
proxy_error(

‎lib/MySQL_Monitor.cpp

+11-10
Original file line numberDiff line numberDiff line change
@@ -2756,6 +2756,7 @@ void * monitor_replication_lag_thread(void *arg) {
27562756
ASSERT_SQLITE_OK(rc, mmsd->mondb);
27572757
// 'replication_lag' to be feed to 'replication_lag_action'
27582758
int repl_lag=-2;
2759+
bool override_repl_lag = true;
27592760
rc=(*proxy_sqlite3_bind_text)(statement, 1, mmsd->hostname, -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, mmsd->mondb);
27602761
rc=(*proxy_sqlite3_bind_int)(statement, 2, mmsd->port); ASSERT_SQLITE_OK(rc, mmsd->mondb);
27612762
unsigned long long time_now=realtime_time();
@@ -2792,16 +2793,16 @@ void * monitor_replication_lag_thread(void *arg) {
27922793
MYSQL_ROW row=mysql_fetch_row(mmsd->result);
27932794
if (row) {
27942795
repl_lag=-1; // this is old behavior
2795-
repl_lag=mysql_thread___monitor_slave_lag_when_null; // new behavior, see 669
2796+
override_repl_lag = true;
27962797
if (row[j]) { // if Seconds_Behind_Master is not NULL
27972798
repl_lag=atoi(row[j]);
2799+
override_repl_lag = false;
27982800
} else {
2799-
proxy_error("Replication lag on server %s:%d is NULL, using the value %d (mysql-monitor_slave_lag_when_null)\n", mmsd->hostname, mmsd->port, mysql_thread___monitor_slave_lag_when_null);
28002801
MyHGM->p_update_mysql_error_counter(p_mysql_error_type::proxysql, mmsd->hostgroup_id, mmsd->hostname, mmsd->port, ER_PROXYSQL_SRV_NULL_REPLICATION_LAG);
28012802
}
28022803
}
28032804
}
2804-
if (repl_lag>=0) {
2805+
if (/*repl_lag >= 0 ||*/ override_repl_lag == false) {
28052806
rc=(*proxy_sqlite3_bind_int64)(statement, 5, repl_lag); ASSERT_SQLITE_OK(rc, mmsd->mondb);
28062807
} else {
28072808
rc=(*proxy_sqlite3_bind_null)(statement, 5); ASSERT_SQLITE_OK(rc, mmsd->mondb);
@@ -2822,7 +2823,7 @@ void * monitor_replication_lag_thread(void *arg) {
28222823
rc=(*proxy_sqlite3_clear_bindings)(statement); ASSERT_SQLITE_OK(rc, mmsd->mondb);
28232824
rc=(*proxy_sqlite3_reset)(statement); ASSERT_SQLITE_OK(rc, mmsd->mondb);
28242825
MyHGM->replication_lag_action( std::list<replication_lag_server_t> {
2825-
replication_lag_server_t {mmsd->hostgroup_id, mmsd->hostname, mmsd->port, repl_lag}
2826+
replication_lag_server_t {mmsd->hostgroup_id, mmsd->hostname, mmsd->port, repl_lag, override_repl_lag }
28262827
} );
28272828
(*proxy_sqlite3_finalize)(statement);
28282829
if (mmsd->mysql_error_msg == NULL) {
@@ -7749,8 +7750,7 @@ void MySQL_Monitor::monitor_gr_async_actions_handler(
77497750

77507751

77517752
bool MySQL_Monitor::monitor_replication_lag_process_ready_tasks(const std::vector<MySQL_Monitor_State_Data*>& mmsds) {
7752-
7753-
std::list<std::tuple<int, std::string, unsigned int, int>> mysql_servers;
7753+
std::list<replication_lag_server_t> mysql_servers;
77547754

77557755
for (auto& mmsd : mmsds) {
77567756

@@ -7792,6 +7792,7 @@ bool MySQL_Monitor::monitor_replication_lag_process_ready_tasks(const std::vecto
77927792
ASSERT_SQLITE_OK(rc, mmsd->mondb);
77937793
// 'replication_lag' to be feed to 'replication_lag_action'
77947794
int repl_lag = -2;
7795+
bool override_repl_lag = true;
77957796
rc = (*proxy_sqlite3_bind_text)(statement, 1, mmsd->hostname, -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, mmsd->mondb);
77967797
rc = (*proxy_sqlite3_bind_int)(statement, 2, mmsd->port); ASSERT_SQLITE_OK(rc, mmsd->mondb);
77977798
unsigned long long time_now = realtime_time();
@@ -7828,16 +7829,16 @@ bool MySQL_Monitor::monitor_replication_lag_process_ready_tasks(const std::vecto
78287829
MYSQL_ROW row = mysql_fetch_row(mmsd->result);
78297830
if (row) {
78307831
repl_lag = -1; // this is old behavior
7831-
repl_lag = mysql_thread___monitor_slave_lag_when_null; // new behavior, see 669
7832+
override_repl_lag = true;
78327833
if (row[j]) { // if Seconds_Behind_Master is not NULL
78337834
repl_lag = atoi(row[j]);
7835+
override_repl_lag = false;
78347836
} else {
7835-
proxy_error("Replication lag on server %s:%d is NULL, using the value %d (mysql-monitor_slave_lag_when_null)\n", mmsd->hostname, mmsd->port, mysql_thread___monitor_slave_lag_when_null);
78367837
MyHGM->p_update_mysql_error_counter(p_mysql_error_type::proxysql, mmsd->hostgroup_id, mmsd->hostname, mmsd->port, ER_PROXYSQL_SRV_NULL_REPLICATION_LAG);
78377838
}
78387839
}
78397840
}
7840-
if (repl_lag >= 0) {
7841+
if (/*repl_lag >= 0 ||*/ override_repl_lag == false) {
78417842
rc = (*proxy_sqlite3_bind_int64)(statement, 5, repl_lag); ASSERT_SQLITE_OK(rc, mmsd->mondb);
78427843
} else {
78437844
rc = (*proxy_sqlite3_bind_null)(statement, 5); ASSERT_SQLITE_OK(rc, mmsd->mondb);
@@ -7859,7 +7860,7 @@ bool MySQL_Monitor::monitor_replication_lag_process_ready_tasks(const std::vecto
78597860
rc = (*proxy_sqlite3_reset)(statement); ASSERT_SQLITE_OK(rc, mmsd->mondb);
78607861
//MyHGM->replication_lag_action(mmsd->hostgroup_id, mmsd->hostname, mmsd->port, repl_lag);
78617862
(*proxy_sqlite3_finalize)(statement);
7862-
mysql_servers.push_back( std::tuple<int,std::string,int,int> { mmsd->hostgroup_id, mmsd->hostname, mmsd->port, repl_lag });
7863+
mysql_servers.push_back( replication_lag_server_t { mmsd->hostgroup_id, mmsd->hostname, mmsd->port, repl_lag, override_repl_lag });
78637864
}
78647865

78657866
//executing replication lag action

‎lib/ProxySQL_Cluster.cpp

-14
Original file line numberDiff line numberDiff line change
@@ -530,13 +530,6 @@ void ProxySQL_Node_Entry::set_checksums(MYSQL_RES *_r) {
530530
checksums_values.mysql_servers.checksum, GloVars.checksums_values.mysql_servers.checksum, checksums_values.mysql_servers.diff_check);
531531
}
532532
if (strcmp(checksums_values.mysql_servers.checksum, GloVars.checksums_values.mysql_servers.checksum) == 0) {
533-
// See LOGGING-NOTE at 'admin_variables' above.
534-
if (checksums_values.mysql_servers.last_changed == now) {
535-
proxy_info(
536-
"Cluster: checksum for mysql_servers from peer %s:%d matches with local checksum %s , we won't sync.\n",
537-
hostname, port, GloVars.checksums_values.mysql_servers.checksum
538-
);
539-
}
540533
checksums_values.mysql_servers.diff_check = 0;
541534
proxy_debug(PROXY_DEBUG_CLUSTER, 5, "Checksum for mysql_servers from peer %s:%d matches with local checksum %s, reset diff_check to 0.\n", hostname, port, GloVars.checksums_values.mysql_servers.checksum);
542535
}
@@ -577,13 +570,6 @@ void ProxySQL_Node_Entry::set_checksums(MYSQL_RES *_r) {
577570
checksums_values.mysql_servers_v2.checksum, GloVars.checksums_values.mysql_servers_v2.checksum, checksums_values.mysql_servers_v2.diff_check);
578571
}
579572
if (strcmp(checksums_values.mysql_servers_v2.checksum, GloVars.checksums_values.mysql_servers_v2.checksum) == 0) {
580-
// See LOGGING-NOTE at 'admin_variables' above.
581-
if (checksums_values.mysql_servers_v2.last_changed == now) {
582-
proxy_info(
583-
"Cluster: checksum for mysql_servers_v2 from peer %s:%d matches with local checksum %s , we won't sync.\n",
584-
hostname, port, GloVars.checksums_values.mysql_servers_v2.checksum
585-
);
586-
}
587573
checksums_values.mysql_servers_v2.diff_check = 0;
588574
proxy_debug(PROXY_DEBUG_CLUSTER, 5, "Checksum for mysql_servers_v2 from peer %s:%d matches with local checksum %s, reset diff_check to 0.\n", hostname, port, GloVars.checksums_values.mysql_servers.checksum);
589575
}

‎src/SQLite3_Server.cpp

+22-11
Original file line numberDiff line numberDiff line change
@@ -879,11 +879,17 @@ void SQLite3_Server_session_handler(MySQL_Session *sess, void *_pa, PtrSize_t *p
879879
// probably never initialized
880880
GloSQLite3Server->load_replicationlag_table(sess);
881881
}
882-
const int rc = GloSQLite3Server->replicationlag_test_value(query_no_space + strlen("SELECT SLAVE STATUS "));
882+
const int* rc = GloSQLite3Server->replicationlag_test_value(query_no_space + strlen("SELECT SLAVE STATUS "));
883883
free(query);
884-
char* a = (char*)"SELECT %d as Seconds_Behind_Master";
885-
query = (char*)malloc(strlen(a) + 2);
886-
sprintf(query, a, rc);
884+
if (rc == nullptr) {
885+
const char* a = (char*)"SELECT null as Seconds_Behind_Master";
886+
query = (char*)malloc(strlen(a) + 2);
887+
sprintf(query, a);
888+
} else {
889+
const char* a = (char*)"SELECT %d as Seconds_Behind_Master";
890+
query = (char*)malloc(strlen(a) + 2);
891+
sprintf(query, a, *rc);
892+
}
887893
pthread_mutex_unlock(&GloSQLite3Server->test_replicationlag_mutex);
888894
}
889895
}
@@ -1845,7 +1851,7 @@ bool SQLite3_Server::init() {
18451851
insert_into_tables_defs(tables_defs_replicationlag,
18461852
(const char*)"REPLICATIONLAG_HOST_STATUS",
18471853
(const char*)"CREATE TABLE REPLICATIONLAG_HOST_STATUS ("
1848-
"hostname VARCHAR NOT NULL, port INT NOT NULL, seconds_behind_master INT NOT NULL, PRIMARY KEY (hostname, port)"
1854+
"hostname VARCHAR NOT NULL, port INT NOT NULL, seconds_behind_master INT DEFAULT NULL, PRIMARY KEY (hostname, port)"
18491855
")"
18501856
);
18511857

@@ -2016,27 +2022,32 @@ void SQLite3_Server::load_replicationlag_table(MySQL_Session* sess) {
20162022
for (std::vector<SQLite3_row*>::iterator it = resultset->rows.begin(); it != resultset->rows.end(); ++it) {
20172023
SQLite3_row* r = *it;
20182024
const std::string& s = std::string(r->fields[0]) + ":" + std::string(r->fields[1]);
2019-
replicationlag_map[s] = atoi(r->fields[2]);
2025+
2026+
if (r->fields[2] == nullptr) {
2027+
replicationlag_map[s] = nullptr;
2028+
} else {
2029+
replicationlag_map[s] = std::make_unique<int>(atoi(r->fields[2]));
2030+
}
20202031
}
20212032
}
20222033
delete resultset;
20232034
if (replicationlag_map.size() == 0) {
20242035
GloAdmin->admindb->execute_statement((char*)"SELECT DISTINCT hostname, port FROM mysql_servers WHERE hostgroup_id BETWEEN 5202 AND 5700", &error, &cols, &affected_rows, &resultset);
20252036
for (std::vector<SQLite3_row*>::iterator it = resultset->rows.begin(); it != resultset->rows.end(); ++it) {
20262037
SQLite3_row* r = *it;
2027-
const std::string& s = "INSERT INTO REPLICATIONLAG_HOST_STATUS VALUES ('" + std::string(r->fields[0]) + "'," + std::string(r->fields[1]) + ",0)";
2038+
const std::string& s = "INSERT INTO REPLICATIONLAG_HOST_STATUS VALUES ('" + std::string(r->fields[0]) + "'," + std::string(r->fields[1]) + ",null)";
20282039
sessdb->execute(s.c_str());
20292040
}
20302041
delete resultset;
20312042
}
20322043
GloAdmin->mysql_servers_wrunlock();
20332044
}
20342045

2035-
int SQLite3_Server::replicationlag_test_value(const char* p) {
2036-
int rc = 0; // default
2037-
std::unordered_map<std::string, int>::iterator it = replicationlag_map.find(std::string(p));
2046+
int* SQLite3_Server::replicationlag_test_value(const char* p) {
2047+
int* rc = 0; // default
2048+
std::unordered_map<std::string, std::unique_ptr<int>>::iterator it = replicationlag_map.find(std::string(p));
20382049
if (it != replicationlag_map.end()) {
2039-
rc = it->second;
2050+
rc = it->second.get();
20402051
}
20412052
return rc;
20422053
}

0 commit comments

Comments
 (0)