mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-02-09 23:24:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
mariadb/mysql-test/suite/rpl/r/rpl_semi_sync_event.result
Michael Widenius 7af50e4df4 MDEV-32551: "Read semi-sync reply magic number error" warnings on master 
rpl_semi_sync_slave_enabled_consistent.test and the first part of
the commit message comes from Brandon Nesterenko.

A test to show how to induce the "Read semi-sync reply magic number
error" message on a primary. In short, if semi-sync is turned on
during the hand-shake process between a primary and replica, but
later a user negates the rpl_semi_sync_slave_enabled variable while
the replica's IO thread is running; if the io thread exits, the
replica can skip a necessary call to kill_connection() in
repl_semisync_slave.slave_stop() due to its reliance on a global
variable. Then, the replica will send a COM_QUIT packet to the
primary on an active semi-sync connection, causing the magic number
error.

The test in this patch exits the IO thread by forcing an error;
though note a call to STOP SLAVE could also do this, but it ends up
needing more synchronization. That is, the STOP SLAVE command also
tries to kill the VIO of the replica, which makes a race with the IO
thread to try and send the COM_QUIT before this happens (which would
need more debug_sync to get around). See THD::awake_no_mutex for
details as to the killing of the replica’s vio.

Notes:
- The MariaDB documentation does not make it clear that when one
  enables semi-sync replication it does not matter if one enables
  it first in the master or slave. Any order works.

Changes done:
- The rpl_semi_sync_slave_enabled variable is now a default value for
  when semisync is started. The variable does not anymore affect
  semisync if it is already running. This fixes the original reported
  bug.  Internally we now use repl_semisync_slave.get_slave_enabled()
  instead of rpl_semi_sync_slave_enabled. To check if semisync is
  active on should check the @@rpl_semi_sync_slave_status variable (as
  before).
- The semisync protocol conflicts in the way that the original
  MySQL/MariaDB client-server protocol was designed (client-server
  send and reply packets are strictly ordered and includes a packet
  number to allow one to check if a packet is lost). When using
  semi-sync the master and slave can send packets at 'any time', so
  packet numbering does not work. The 'solution' has been that each
  communication starts with packet number 1, but in some cases there
  is still a chance that the packet number check can fail.  Fixed by
  adding a flag (pkt_nr_can_be_reset) in the NET struct that one can
  use to signal that packet number checking should not be done. This
  is flag is set when semi-sync is used.
- Added Master_info::semi_sync_reply_enabled to allow one to configure
  some slaves with semisync and other other slaves without semisync.
  Removed global variable semi_sync_need_reply that would not work
  with multi-master.
- Repl_semi_sync_master::report_reply_packet() can now recognize
  the COM_QUIT packet from semisync slave and not give a
  "Read semi-sync reply magic number error" error for this case.
  The slave will be removed from the Ack listener.
- On Windows, don't stop semisync Ack listener just because one
  slave connection is using socket_id > FD_SETSIZE.
- Removed busy loop in Ack_receiver::run() by using
 "Self-pipe trick" to signal new slave and stop Ack_receiver.
- Changed some Repl_semi_sync_slave functions that always returns 0
  from int to void.
- Added Repl_semi_sync_slave::slave_reconnect().
- Removed dummy_function Repl_semi_sync_slave::reset_slave().
- Removed some duplicate semisync notes from the error log.
- Add test of "if (get_slave_enabled() && semi_sync_need_reply)"
  before calling Repl_semi_sync_slave::slave_reply().
  (Speeds up the code as we can skip all initializations).
- If epl_semisync_slave.slave_reply() fails, we disable semisync
  for that connection.
- We do not call semisync.switch_off() if there are no active slaves.
  Instead we check in Repl_semi_sync_master::commit_trx() if there are
  no active threads. This simplices the code.
- Changed assert() to DBUG_ASSERT() to ensure that the DBUG log is
  flushed in case of asserts.
- Removed the internal rpl_semi_sync_slave_status as it is not needed
  anymore. The @@rpl_semi_sync_slave_status status variable is now
  mapped to rpl_semi_sync_enabled.
- Removed rpl_semi_sync_slave_enabled  as it is not needed anymore.
  Repl_semi_sync_slave::get_slave_enabled() contains the active status.
- Added checking that we do not add a slave twice with
  Ack_receiver::add_slave(). This could happen with old code.
- Removed Repl_semi_sync_master::check_and_switch() as it is not
  needed anymore.
- Ensure that when we call Ack_receiver::remove_slave() that the slave
  is removed from the listener before function returns.
- Call listener.listen_on_sockets() outside of mutex for better
  performance and less contested mutex.
- Ensure that listening is ignoring newly added slaves when checking for
  responses.
- Fixed the master ack_receiver listener is not killed if there are no
  connected slaves (and thus stop semisync handling of future
  connections). This could happen if all slaves sockets where would be
  marked as unreliable.
- Added unlink() to base_ilist_iterator and remove() to
  I_List_iterator. This enables us to remove 'dead' slaves in
  Ack_recever::run().
- kill_zombie_dump_threads() now does killing of dump threads properly.
  - It can now kill several threads (should be impossible but could
    happen if IO slaves reconnects very fast).
  - We now wait until the dump thread is done before starting the
    dump.
- Added an error if kill_zombie_dump_threads() fails.
- Set thd->variables.server_id before calling
  kill_zombie_dump_threads(). This simplies the code.
- Added a lot of comments both in code and tests.
- Removed DBUG_EVALUATE_IF "failed_slave_start" as it is not used.

Test changes:
- rpl.rpl_session_var2 added which runs rpl.rpl_session_var test with
  semisync enabled.
- Some timings changed slight with startup of slave which caused
  rpl_binlog_dump_slave_gtid_state_info.text to fail as it checked the
  error log file before the slave had started properly. Fixed by
  adding wait_for_pattern_in_file.inc that allows waiting for the
  pattern to appear in the log file.
- Tests have been updated so that we first set
  rpl_semi_sync_master_enabled on the master and then set
  rpl_semi_sync_slave_enabled on the slaves (this is according to how
  the MariaDB documentation document how to setup semi-sync).
- Error text "Master server does not have semi-sync enabled" has been
  replaced with "Master server does not support semi-sync" for the
  case when the master supports semi-sync but semi-sync is not
  enabled.

Other things:
- Some trivial cleanups in Repl_semi_sync_master::update_sync_header().
- We should in 11.3 changed the default value for
  rpl-semi-sync-master-wait-no-slave from TRUE to FALSE as the TRUE
  does not make much sense as default. The main difference with using
  FALSE is that we do not wait for semisync Ack if there are no slave
  threads.  In the case of TRUE we wait once, which did not bring any
  notable benefits except slower startup of master configured for
  using semisync.

Co-author: Brandon Nesterenko <brandon.nesterenko@mariadb.com>

This solves the problem reported in MDEV-32960 where a new
slave may not be registered in time and the master disables
semi sync because of that.
2024-01-23 13:03:11 +02:00

165 lines
4.9 KiB
Text
Raw Permalink Blame History

include/master-slave.inc
[connection master]
connection master;
call mtr.add_suppression("Timeout waiting for reply of binlog");
call mtr.add_suppression("Semi-sync master .* waiting for slave reply");
call mtr.add_suppression("Read semi-sync reply");
call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT.");
call mtr.add_suppression("mysqld: Got an error reading communication packets");
connection slave;
call mtr.add_suppression("Semi-sync slave .* reply");
call mtr.add_suppression("Slave SQL.*Request to stop slave SQL Thread received while applying a group that has non-transactional changes; waiting for completion of the group");
connection master;
set global rpl_semi_sync_master_enabled = 1;
connection slave;
include/stop_slave.inc
set global rpl_semi_sync_slave_enabled = 1;
include/start_slave.inc
connection master;
SET GLOBAL event_scheduler = ON;
CREATE TABLE t1 (i INT NOT NULL AUTO_INCREMENT PRIMARY KEY, f varchar(8)) ENGINE=ENGINE_TYPE;
INSERT INTO t1 (f) VALUES ('a'),('a'),('a'),('a'),('a');
INSERT INTO t1 SELECT i+5, f FROM t1;
INSERT INTO t1 SELECT i+10, f FROM t1;
CREATE EVENT ev1 ON SCHEDULE EVERY 1 SECOND
DO INSERT INTO t1 VALUES (SLEEP(5),CONCAT('ev1_',CONNECTION_ID()));
CREATE EVENT ev2 ON SCHEDULE EVERY 1 SECOND
DO INSERT INTO t1 VALUES (SLEEP(5),CONCAT('ev2_',CONNECTION_ID()));
connection slave;
STOP SLAVE IO_THREAD;
connection master;
connect m$run,localhost,root,,;
connection m20;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 20;
connection master;
connect m$run,localhost,root,,;
connection m19;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 19;
connection master;
connect m$run,localhost,root,,;
connection m18;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 18;
connection master;
connect m$run,localhost,root,,;
connection m17;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 17;
connection master;
connect m$run,localhost,root,,;
connection m16;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 16;
connection master;
connect m$run,localhost,root,,;
connection m15;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 15;
connection master;
connect m$run,localhost,root,,;
connection m14;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 14;
connection master;
connect m$run,localhost,root,,;
connection m13;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 13;
connection master;
connect m$run,localhost,root,,;
connection m12;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 12;
connection master;
connect m$run,localhost,root,,;
connection m11;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 11;
connection master;
connect m$run,localhost,root,,;
connection m10;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 10;
connection master;
connect m$run,localhost,root,,;
connection m9;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 9;
connection master;
connect m$run,localhost,root,,;
connection m8;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 8;
connection master;
connect m$run,localhost,root,,;
connection m7;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 7;
connection master;
connect m$run,localhost,root,,;
connection m6;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 6;
connection master;
connect m$run,localhost,root,,;
connection m5;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 5;
connection master;
connect m$run,localhost,root,,;
connection m4;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 4;
connection master;
connect m$run,localhost,root,,;
connection m3;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 3;
connection master;
connect m$run,localhost,root,,;
connection m2;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 2;
connection master;
connect m$run,localhost,root,,;
connection m1;
UPDATE t1 SET f = CONCAT('up_',CONNECTION_ID()) WHERE i = 1;
connection master;
connection master;
SET GLOBAL event_scheduler = OFF;
connection m20;
disconnect m20;
connection m19;
disconnect m19;
connection m18;
disconnect m18;
connection m17;
disconnect m17;
connection m16;
disconnect m16;
connection m15;
disconnect m15;
connection m14;
disconnect m14;
connection m13;
disconnect m13;
connection m12;
disconnect m12;
connection m11;
disconnect m11;
connection m10;
disconnect m10;
connection m9;
disconnect m9;
connection m8;
disconnect m8;
connection m7;
disconnect m7;
connection m6;
disconnect m6;
connection m5;
disconnect m5;
connection m4;
disconnect m4;
connection m3;
disconnect m3;
connection m2;
disconnect m2;
connection m1;
disconnect m1;
connection slave;
include/stop_slave.inc
set global rpl_semi_sync_slave_enabled = 0;
connection master;
set global rpl_semi_sync_master_enabled = 0;
connection slave;
include/start_slave.inc
connection master;
DROP EVENT ev1;
DROP EVENT ev2;
DROP TABLE t1;
connection slave;
include/rpl_end.inc
Reference in a new issue View git blame Copy permalink