1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
# ==== Purpose ====
#
# Verify that START SLAVE UNTIL replicates until the given binlog
# position but not longer. Verify that START SLAVE UNTIL with various
# incorrect arguments gives an error.
#
# ==== Method ====
#
# On master, create a table and insert some rows. On slave, START
# SLAVE UNTIL so that it reads one event at a time, and check the
# table and the slave status each time.
#
# Then, on slave, run START SLAVE UNTIL with incorrect arguments and
# verify that it gives an error.
#
# ==== Related bugs ====
#
# Bug in this test: BUG#37717: rpl.rpl_stm_until 'stmt' fails sporadically on pushbuild
-- source include/have_binlog_format_mixed_or_statement.inc
-- source include/master-slave.inc
--let $master_use_gtid_option= No
-- source include/rpl_reset.inc
# Test is dependent on binlog positions
call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT");
# prepare version for substitutions
let $VERSION=`select version()`;
# Stop slave before it starts replication. Also sync with master
# to avoid nondeterministic behaviour.
sync_slave_with_master;
--source include/stop_slave.inc
--echo ==== Create some events on master ====
connection master;
create table t1(n int not null auto_increment primary key);
insert into t1 values (1),(2),(3),(4);
let $master_log_pos_1= query_get_value(SHOW MASTER STATUS, Position, 1);
let $master_log_file= query_get_value(SHOW MASTER STATUS, File, 1);
drop table t1;
create table t2(n int not null auto_increment primary key);
insert into t2 values (1),(2);
let $master_log_pos_2= query_get_value(SHOW MASTER STATUS, Position, 1);
insert into t2 values (3),(4);
drop table t2;
--echo ==== Replicate one event at a time on slave ====
# try to replicate all queries until drop of t1
connection slave;
--replace_result $master_log_file MASTER_LOG_FILE $master_log_pos_1 MASTER_LOG_POS
eval start slave until master_log_file='$master_log_file', master_log_pos=$master_log_pos_1;
--source include/wait_for_slave_io_to_start.inc
--source include/wait_for_slave_sql_to_stop.inc
# here table should be still not deleted
select * from t1;
--let $slave_param= Exec_Master_Log_Pos
--let $slave_param_value= $master_log_pos_1
--source include/check_slave_param.inc
# this should fail right after start
start slave until master_log_file='master-no-such-bin.000001', master_log_pos=291;
--source include/wait_for_slave_io_to_start.inc
--source include/wait_for_slave_sql_to_stop.inc
# again this table should be still not deleted
select * from t1;
--let $slave_param= Exec_Master_Log_Pos
--let $slave_param_value= $master_log_pos_1
--source include/check_slave_param.inc
let $relay_log_file= slave-relay-bin.000003;
let $master_log_pos= $master_log_pos_2;
source include/get_relay_log_pos.inc;
# try replicate all up to and not including the second insert to t2;
--replace_result $relay_log_pos RELAY_LOG_POS
eval start slave until relay_log_file='$relay_log_file', relay_log_pos=$relay_log_pos;
--source include/wait_for_slave_io_to_start.inc
--source include/wait_for_slave_sql_to_stop.inc
select * from t2;
--let $slave_param= Exec_Master_Log_Pos
--let $slave_param_value= $master_log_pos
--source include/check_slave_param.inc
# clean up
start slave;
connection master;
sync_slave_with_master;
--source include/stop_slave.inc
--let $exec_log_pos_1= query_get_value(SHOW SLAVE STATUS, Exec_Master_Log_Pos, 1)
# this should stop immediately as we are already there
--replace_result $master_log_file MASTER_LOG_FILE $master_log_pos_2 MASTER_LOG_POS
eval start slave until master_log_file='$master_log_file', master_log_pos=$master_log_pos_2;
--source include/wait_for_slave_io_to_start.inc
--source include/wait_for_slave_sql_to_stop.inc
--let $slave_param= Exec_Master_Log_Pos
--let $slave_param_value= $exec_log_pos_1
--source include/check_slave_param.inc
--echo ==== Test various error conditions ====
--error 1277
start slave until master_log_file='master-bin', master_log_pos=561;
--error 1277
start slave until master_log_file='master-bin.000001', master_log_pos=561, relay_log_pos=12;
--error 1277
start slave until master_log_file='master-bin.000001';
--error 1277
start slave until relay_log_file='slave-relay-bin.000002';
--error 1277
start slave until relay_log_file='slave-relay-bin.000002', master_log_pos=561;
# Warning should be given for second command
start slave sql_thread;
start slave until master_log_file='master-bin.000001', master_log_pos=776;
#
# bug#47210 first execution of "start slave until" stops too early
#
# testing that a slave rotate event that is caused by stopping the slave
# does not intervene anymore in UNTIL condition.
#
connection slave;
source include/stop_slave.inc;
--disable_warnings
drop table if exists t1;
--enable_warnings
--source include/reset_slave.inc
--replace_result $MASTER_MYPORT MASTER_PORT
eval change master to master_host='127.0.0.1',master_port=$MASTER_MYPORT, master_user='root';
connection master;
--disable_warnings
drop table if exists t1;
--enable_warnings
reset master;
create table t1 (a int primary key auto_increment);
save_master_pos;
let $master_pos= query_get_value(SHOW MASTER STATUS, Position, 1);
connection slave;
start slave;
sync_with_master;
# at this point slave will close the relay log stamping it with its own
# Rotate log event. This event won't be examined on matter of the master
# UNTIL pos anymore.
source include/stop_slave.inc;
let $slave_exec_pos= query_get_value(SHOW SLAVE STATUS, Exec_Master_Log_Pos, 1);
--echo master and slave are in sync now
let $diff_pos= `select $master_pos - $slave_exec_pos`;
eval select $diff_pos as zero;
connection master;
insert into t1 set a=null;
let $until_pos= query_get_value(SHOW MASTER STATUS, Position, 1);
insert into t1 set a=null;
select count(*) as two from t1;
connection slave;
--replace_result $master_log_file MASTER_LOG_FILE $until_pos UNTIL_POS;
eval start slave until master_log_file='$master_log_file', master_log_pos= $until_pos;
source include/wait_for_slave_sql_to_stop.inc;
let $slave_exec_pos= query_get_value(SHOW SLAVE STATUS, Exec_Master_Log_Pos, 1);
--echo slave stopped at the prescribed position
let $diff_pos= `select $until_pos - $slave_exec_pos`;
eval select $diff_pos as zero;
select count(*) as one from t1;
connection master;
drop table t1;
connection slave;
start slave;
sync_with_master;
# End of tests
--let $rpl_only_running_threads= 1
--source include/rpl_end.inc
|
