Debian Codegraph @

mysql-test/suite/group_replication/t/gr_write_concurrency.test

raw
1 ###############################################################################
2 # WL#11512
3 # Perform some simple tests about getting/setting write_concurrency.
4 #
5 # This test uses 2 servers M1 and M2
6 # M1 -> server1, M2 -> server2
7 #
8 # Test:
9 # 1. Start 2 servers and add them into group replication group
10 # 2. Default value on M1, M2
11 # 3. Increase write_concurrency via M1, confirm on M1, M2
12 # 4. Decrease write_concurrency via M2, confirm on M1, M2
13 # 5. Invalid calls to group_replication_get_write_concurrency on M1
14 # 6. Invalid calls to group_replication_set_write_concurrency on M1
15 # 7. Check that it is not possible to modify/query write_concurrency value when
16 # a server is in RECOVERING state.
17 # 8. Check that it is not possible to update wc value when a member is in ERROR
18 # state.
19 # 9. Stop GR and try to call group_replication_{get,set}_write_concurrency
20 # outside of a group
21 ################################################################################
22 --source include/have_debug_sync.inc
23 --source include/have_group_replication_plugin.inc
24 --let $rpl_server_count= 2
25 --source include/group_replication.inc
26
27 # Create table with integers to test UDF further down.
28 CREATE TABLE t1 (i INT, v INT, PRIMARY KEY (i));
29 INSERT INTO t1 VALUES (1, NULL);
30 INSERT INTO t1 VALUES (2, 9);
31 INSERT INTO t1 VALUES (3, 42);
32 INSERT INTO t1 VALUES (4, 201);
33
34 --let $gr_write_concurrency_default= 10
35
36 --echo ###############################################################################
37 --echo # 2. Confirm default value on M1, M2
38 --let $rpl_connection_name= server1
39 --source include/rpl_connection.inc
40
41 --let $assert_text = write_concurrency is supposed to be $gr_write_concurrency_default by default
42 --let $assert_cond = [SELECT group_replication_get_write_concurrency()] = $gr_write_concurrency_default
43 --source include/assert.inc
44
45 --let $write_concurrency_table= query_get_value(SELECT write_concurrency FROM performance_schema.replication_group_communication_information, write_concurrency, 1)
46 --let $assert_text= write_concurrency ($write_concurrency_table) should be $gr_write_concurrency_default
47 --let $assert_cond= "$write_concurrency_table" = "$gr_write_concurrency_default"
48 --source include/assert.inc
49
50 --let $rpl_connection_name= server2
51 --source include/rpl_connection.inc
52 SET SESSION sql_log_bin = 0;
53 call mtr.add_suppression("Could not execute Write_rows event on table test.t2; Duplicate entry '11'*");
54 call mtr.add_suppression("The applier thread execution was aborted. Unable to process more transactions, this member will now leave the group.");
55 call mtr.add_suppression("Fatal error during execution on the Applier process of Group Replication. The server will now leave the group.");
56 call mtr.add_suppression("The server was automatically set into read only mode after an error was detected.");
57 call mtr.add_suppression("Skipping leave operation: concurrent attempt to leave the group is on-going.");
58 call mtr.add_suppression(".*Replica SQL for channel 'group_replication_applier': ... The replica coordinator and worker threads are stopped, possibly leaving data in inconsistent state*");
59 SET SESSION sql_log_bin = 1;
60
61 --let $assert_text = write_concurrency is supposed to be $gr_write_concurrency_default by default
62 --let $assert_cond = [SELECT group_replication_get_write_concurrency()] = $gr_write_concurrency_default
63 --source include/assert.inc
64
65 --let $write_concurrency_table= query_get_value(SELECT write_concurrency FROM performance_schema.replication_group_communication_information, write_concurrency, 1)
66 --let $assert_text= write_concurrency ($write_concurrency_table) should be $gr_write_concurrency_default
67 --let $assert_cond= "$write_concurrency_table" = "$gr_write_concurrency_default"
68 --source include/assert.inc
69
70 --echo ###############################################################################
71 --echo # 3. Increase write_concurrency via M1, confirm on M1, M2
72 --let $gr_new_write_concurrency= 42
73
74 --let $rpl_connection_name= server1
75 --source include/rpl_connection.inc
76
77 --eval SELECT group_replication_set_write_concurrency($gr_new_write_concurrency)
78
79 --let $wait_condition= SELECT group_replication_get_write_concurrency() = $gr_new_write_concurrency
80 --source include/wait_condition.inc
81
82 --let $write_concurrency_table= query_get_value(SELECT write_concurrency FROM performance_schema.replication_group_communication_information, write_concurrency, 1)
83 --let $assert_text= write_concurrency ($write_concurrency_table) should be $gr_new_write_concurrency
84 --let $assert_cond= "$write_concurrency_table" = "$gr_new_write_concurrency"
85 --source include/assert.inc
86
87 --let $rpl_connection_name= server2
88 --source include/rpl_connection.inc
89
90 --let $wait_condition= SELECT group_replication_get_write_concurrency() = $gr_new_write_concurrency
91 --source include/wait_condition.inc
92
93 --let $write_concurrency_table= query_get_value(SELECT write_concurrency FROM performance_schema.replication_group_communication_information, write_concurrency, 1)
94 --let $assert_text= write_concurrency ($write_concurrency_table) should be $gr_new_write_concurrency
95 --let $assert_cond= "$write_concurrency_table" = "$gr_new_write_concurrency"
96 --source include/assert.inc
97
98 --echo ###############################################################################
99 --echo # 4. Decrease write_concurrency via M2, confirm on M1, M2
100 --let $gr_new_write_concurrency= 10
101
102 --eval SELECT group_replication_set_write_concurrency($gr_new_write_concurrency)
103
104 --let $wait_condition= SELECT group_replication_get_write_concurrency() = $gr_new_write_concurrency
105 --source include/wait_condition.inc
106
107 --let $write_concurrency_table= query_get_value(SELECT write_concurrency FROM performance_schema.replication_group_communication_information, write_concurrency, 1)
108 --let $assert_text= write_concurrency ($write_concurrency_table) should be $gr_new_write_concurrency
109 --let $assert_cond= "$write_concurrency_table" = "$gr_new_write_concurrency"
110 --source include/assert.inc
111
112 --let $rpl_connection_name= server1
113 --source include/rpl_connection.inc
114
115 --let $wait_condition= SELECT group_replication_get_write_concurrency() = $gr_new_write_concurrency
116 --source include/wait_condition.inc
117
118 --let $write_concurrency_table= query_get_value(SELECT write_concurrency FROM performance_schema.replication_group_communication_information, write_concurrency, 1)
119 --let $assert_text= write_concurrency ($write_concurrency_table) should be $gr_new_write_concurrency
120 --let $assert_cond= "$write_concurrency_table" = "$gr_new_write_concurrency"
121 --source include/assert.inc
122
123 --echo ###############################################################################
124 --echo # 5. Confirm invalid calls to group_replication_get_write_concurrency
125 --error ER_CANT_INITIALIZE_UDF
126 SELECT group_replication_get_write_concurrency(1);
127
128 --error ER_CANT_INITIALIZE_UDF
129 SELECT group_replication_get_write_concurrency(1.1);
130
131 --error ER_CANT_INITIALIZE_UDF
132 SELECT group_replication_get_write_concurrency("hehe");
133
134 --error ER_CANT_INITIALIZE_UDF
135 SELECT group_replication_get_write_concurrency(NULL);
136
137 --echo ###############################################################################
138 --echo # 6. Confirm invalid calls to group_replication_set_write_concurrency
139 --error ER_CANT_INITIALIZE_UDF
140 SELECT group_replication_set_write_concurrency();
141
142 --error ER_CANT_INITIALIZE_UDF
143 SELECT group_replication_set_write_concurrency(NULL);
144
145 --error ER_CANT_INITIALIZE_UDF
146 SELECT group_replication_set_write_concurrency(1.1);
147
148 --error ER_CANT_INITIALIZE_UDF
149 SELECT group_replication_set_write_concurrency("hehe");
150
151 # out of [10, 200] domain
152 --error ER_CANT_INITIALIZE_UDF
153 SELECT group_replication_set_write_concurrency(9);
154
155 --error ER_CANT_INITIALIZE_UDF
156 SELECT group_replication_set_write_concurrency(4097);
157
158 # With dynamic arguments, the error returned is ER_GRP_RPL_UDF_ERROR
159
160 # NULL
161 --error ER_GRP_RPL_UDF_ERROR
162 SELECT group_replication_set_write_concurrency(v) FROM test.t1 WHERE i=1;
163
164 # 9
165 --error ER_GRP_RPL_UDF_ERROR
166 SELECT group_replication_set_write_concurrency(v) FROM test.t1 WHERE i=2;
167
168 # 42
169 SELECT group_replication_set_write_concurrency(v) FROM test.t1 WHERE i=3;
170
171 # 201
172 --error ER_GRP_RPL_UDF_ERROR
173 SELECT group_replication_set_write_concurrency(v) FROM test.t1 WHERE i=4;
174
175 # Stop GR on M2
176 --let $rpl_connection_name= server2
177 --source include/rpl_connection.inc
178 --source include/stop_group_replication.inc
179
180 --echo ###############################################################################
181 --echo # 7. Check that it is not possible to modify/query write_concurrency value when server is in RECOVERING state.
182 # Start GR on M2, It should be in RECOVERING state.
183 --let $rpl_connection_name= server2
184 --source include/rpl_connection.inc
185 SET @@GLOBAL.DEBUG='+d,recovery_thread_wait_before_finish';
186
187 --let $group_replication_start_member_state= RECOVERING
188 --source include/start_group_replication.inc
189
190 --let $gr_new_write_concurrency= 111
191 # Since M2 is in RECOVERY state, it shouldn't allow to modify write concurrency value.
192 --error ER_CANT_INITIALIZE_UDF
193 --eval SELECT group_replication_set_write_concurrency($gr_new_write_concurrency)
194
195 # Check that it is not possible to query write_concurrency value either.
196 --error ER_CANT_INITIALIZE_UDF
197 --eval SELECT group_replication_get_write_concurrency()
198
199 --echo ###############################################################################
200 --echo # 8. Check that it is not possible to update wc value when a member is in ERROR state.
201 --let $rpl_connection_name= server2
202 --source include/rpl_connection.inc
203 SET DEBUG_SYNC= "now WAIT_FOR signal.recovery_thread_wait_before_finish_reached";
204 SET @@GLOBAL.DEBUG='-d,recovery_thread_wait_before_finish';
205 SET DEBUG_SYNC= "now SIGNAL signal.recovery_end";
206
207 # Wait until M2 becomes ONLINE
208 --echo Wait until server2 becomes ONLINE
209 --let $wait_condition=SELECT COUNT(*)=2 FROM performance_schema.replication_group_members where MEMBER_STATE="ONLINE"
210 --source include/wait_condition.inc
211
212 --let $group_replication_member_state= ONLINE
213 --source include/gr_wait_for_member_state.inc
214
215 SET DEBUG_SYNC= 'RESET';
216
217 # Create a table.
218 CREATE TABLE t2 (a INT PRIMARY KEY);
219 --source include/rpl_sync.inc
220
221 # Insert some data onto t2 with sql_log_bin=0 so that M2 goes to ERROR state.
222 --let $rpl_connection_name= server2
223 --source include/rpl_connection.inc
224 SET SESSION sql_log_bin=0;
225 INSERT INTO t2 values(11);
226 SET SESSION sql_log_bin=1;
227
228 --let $rpl_connection_name= server1
229 --source include/rpl_connection.inc
230 INSERT INTO t2 values(11);
231
232 # Wait until M2 goes to ERROR state.
233 --let $rpl_connection_name= server2
234 --source include/rpl_connection.inc
235 --echo wait until server2 goes to ERROR state.
236 --let $wait_condition=SELECT COUNT(*)=1 FROM performance_schema.replication_group_members where MEMBER_STATE="ERROR"
237 --source include/wait_condition.inc
238
239 --let $gr_new_write_concurrency= 11
240 # Since M2 is in ERROR state, it shouldn't allow to modify write concurrency value.
241 --error ER_CANT_INITIALIZE_UDF
242 --eval SELECT group_replication_set_write_concurrency($gr_new_write_concurrency)
243
244 # Ensure that, on M2 we cannot query WC value
245 --error ER_CANT_INITIALIZE_UDF
246 --eval SELECT group_replication_get_write_concurrency()
247
248 --source include/stop_group_replication.inc
249
250 # Add M2 back to group.
251 SET SESSION sql_log_bin=0;
252 DELETE FROM t2;
253 SET SESSION sql_log_bin=1;
254 --source include/start_group_replication.inc
255
256 DROP TABLE t1;
257 DROP TABLE t2;
258 --source include/rpl_sync.inc
259
260 --echo ###############################################################################
261 --echo # 9. Stop GR and try to call group_replication_{get,set}_write_concurrency outside of a group
262 --let $rpl_connection_name= server1
263 --source include/rpl_connection.inc
264
265 --source include/group_replication_end.inc
266
267 --error ER_CANT_INITIALIZE_UDF
268 SELECT group_replication_get_write_concurrency();
269
270 --error ER_CANT_INITIALIZE_UDF
271 SELECT group_replication_set_write_concurrency(10);