MySQL 8.0.30
Source Code Documentation
rpl_mi.h
Go to the documentation of this file.
1/* Copyright (c) 2006, 2022, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23#ifndef RPL_MI_H
24#define RPL_MI_H
25
26#include <sys/types.h>
27#include <time.h>
28#include <atomic>
29
30#include "compression.h" // COMPRESSION_ALGORITHM_NAME_BUFFER_SIZE
31#include "libbinlogevents/include/binlog_event.h" // enum_binlog_checksum_alg
32#include "m_string.h"
33#include "my_inttypes.h"
34#include "my_io.h"
35#include "my_psi_config.h"
38#include "mysql_com.h"
39#include "sql/binlog.h"
40#include "sql/log_event.h" // Format_description_log_event
41#include "sql/rpl_gtid.h" // Gtid
42#include "sql/rpl_info.h" // Rpl_info
43#include "sql/rpl_rli.h" // rli->get_log_lock()
44#include "sql/rpl_trx_boundary_parser.h" // Transaction_boundary_parser
45#include "sql/sql_const.h"
46
48class Server_ids;
49class THD;
50struct MYSQL;
51
52#define DEFAULT_CONNECT_RETRY 60
53
54/*****************************************************************************
55 Replication IO Thread
56
57 Master_info contains:
58 - information about how to connect to a master
59 - current master log name
60 - current master log offset
61 - misc control variables
62
63 Master_info is initialized once from the master.info repository if such
64 exists. Otherwise, data members corresponding to master.info fields
65 are initialized with defaults specified by master-* options. The
66 initialization is done through mi_init_info() call.
67
68 Logically, the format of master.info repository is presented as follows:
69
70 log_name
71 log_pos
72 master_host
73 master_user
74 master_pass
75 master_port
76 master_connect_retry
77
78 To write out the contents of master.info to disk a call to flush_info()
79 is required. Currently, it is needed every time we read and queue data
80 from the master.
81
82 To clean up, call end_info()
83
84*****************************************************************************/
85
86class Master_info : public Rpl_info {
87 friend class Rpl_info_factory;
88
89 public:
90 /**
91 Host name or ip address stored in the master.info.
92 */
94
95 /*
96 Check if the channel is configured.
97
98 @param mi Pointer to Master_info.
99
100 @retval true The channel is configured.
101 @retval false The channel is not configured.
102 */
103 static bool is_configured(Master_info *mi) { return mi && mi->host[0]; }
104
105 private:
106 /**
107 If true, USER/PASSWORD was specified when running START SLAVE.
108 */
110 /**
111 User's name stored in the master.info.
112 */
114 /**
115 User's password stored in the master.info.
116 */
118 /**
119 User specified when running START SLAVE.
120 */
122 /**
123 Password specified when running START SLAVE.
124 */
126 /**
127 Stores the authentication plugin specified when running START SLAVE.
128 */
130 /**
131 Stores the authentication plugin directory specified when running
132 START SLAVE.
133 */
135
136 /// Information on the current and last queued transactions
138
139#ifdef HAVE_PSI_INTERFACE
140 /**
141 PSI key for the `rotate_lock`
142 */
144 /**
145 PSI key for the `rotate_cond`
146 */
148#endif
149 /**
150 Lock to protect from rotating the relay log when in the middle of a
151 transaction.
152 */
154 /**
155 Waiting condition that will block the process/thread requesting a relay log
156 rotation in the middle of a transaction. The process/thread will wait until
157 the transaction is written to the relay log and the rotation is,
158 successfully accomplished.
159 */
161 /**
162 If a rotate was requested while the relay log was in a transaction.
163 */
164 std::atomic<bool> rotate_requested{false};
165
166 public:
167 /**
168 Returns if USER/PASSWORD was specified when running
169 START SLAVE.
170
171 @return true or false.
172 */
174 /**
175 Returns if DEFAULT_AUTH was specified when running START SLAVE.
176
177 @return true or false.
178 */
180 return (start_plugin_auth[0] != 0);
181 }
182 /**
183 Returns if PLUGIN_DIR was specified when running START SLAVE.
184
185 @return true or false.
186 */
188 return (start_plugin_dir[0] != 0);
189 }
190 /**
191 Defines that USER/PASSWORD was specified or not when running
192 START SLAVE.
193
194 @param config is true or false.
195 */
196 void set_start_user_configured(bool config) {
197 start_user_configured = config;
198 }
199 /**
200 Sets either user's name in the master.info repository when CHANGE
201 MASTER is executed or user's name used in START SLAVE if USER is
202 specified.
203
204 @param user_arg is user's name.
205 */
206 void set_user(const char *user_arg) {
207 if (user_arg && start_user_configured) {
208 strmake(start_user, user_arg, sizeof(start_user) - 1);
209 } else if (user_arg) {
210 strmake(user, user_arg, sizeof(user) - 1);
211 }
212 }
213 /**
214 Returns user's size name. See @c get_user().
215
216 @return user's size name.
217 */
218 size_t get_user_size() const {
219 return (start_user_configured ? sizeof(start_user) : sizeof(user));
220 }
221 /**
222 If an user was specified when running START SLAVE, this function returns
223 such user. Otherwise, it returns the user stored in master.info.
224
225 @return user's name.
226 */
227 const char *get_user() const {
229 }
230 /**
231 Stores either user's password in the master.info repository when CHANGE
232 MASTER is executed or user's password used in START SLAVE if PASSWORD
233 is specified.
234
235 @param password_arg is user's password.
236
237 */
238 void set_password(const char *password_arg);
239 /**
240 Returns either user's password in the master.info repository or
241 user's password used in START SLAVE.
242
243 @param[out] password_arg is user's password.
244 @param[out] password_arg_size is user's password size.
245
246 @return false if there is no error, otherwise true is returned.
247 */
248 bool get_password(char *password_arg, size_t *password_arg_size);
249 /**
250 Cleans in-memory password defined by START SLAVE.
251 */
252 void reset_start_info();
253 /**
254 Returns the DEFAULT_AUTH defined by START SLAVE.
255
256 @return DEFAULT_AUTH.
257 */
258 const char *get_start_plugin_auth() { return start_plugin_auth; }
259 /**
260 Returns the PLUGIN_DIR defined by START SLAVE.
261
262 @return PLUGIN_DIR.
263 */
264 const char *get_start_plugin_dir() { return start_plugin_dir; }
265 /**
266 Stores the DEFAULT_AUTH defined by START SLAVE.
267 */
268 void set_plugin_auth(const char *src) {
269 if (src) strmake(start_plugin_auth, src, sizeof(start_plugin_auth) - 1);
270 }
271 /**
272 Stores the DEFAULT_AUTH defined by START SLAVE.
273 */
274 void set_plugin_dir(const char *src) {
275 if (src) strmake(start_plugin_dir, src, sizeof(start_plugin_dir) - 1);
276 }
277
278 bool ssl; // enables use of SSL connection if true
282 /*
283 Ciphersuites used for TLS 1.3 communication with the master server.
284 tls_ciphersuites = NULL means that TLS 1.3 default ciphersuites
285 are enabled. To allow a value that can either be NULL or a string,
286 it is represented by the pair:
287 first: true if tls_ciphersuites is set to NULL
288 second: the string value when first is false
289 */
290 std::pair<bool, std::string> tls_ciphersuites = {true, ""};
295
297 uint32 file_id; /* for 3.23 load data infile */
301 /*
302 The difference in seconds between the clock of the master and the clock of
303 the slave (second - first). It must be signed as it may be <0 or >0.
304 clock_diff_with_master is computed when the I/O thread starts; for this the
305 I/O thread does a SELECT UNIX_TIMESTAMP() on the master.
306 "how late the slave is compared to the master" is computed like this:
307 clock_of_slave - last_timestamp_executed_by_SQL_thread -
308 clock_diff_with_master
309
310 */
312 float heartbeat_period; // interface with CHANGE MASTER or master.info
313 ulonglong received_heartbeats; // counter of received heartbeat events
314
316
318
320 /*
321 to hold checksum alg in use until IO thread has received FD.
322 Initialized to novalue, then set to the queried from master
323 @@global.binlog_checksum and deactivated once FD has been received.
324 */
329
330 /*
331 Name of a network namespace where a socket for connection to a master
332 should be created.
333 */
335
336 bool is_set_network_namespace() const { return network_namespace[0] != 0; }
337
338 const char *network_namespace_str() const {
340 }
341 /*
342 describes what compression algorithm and level is used between
343 master/slave communication protocol
344 */
347 NET_SERVER server_extn; // maintain compress context info.
348
349 int mi_init_info();
350 void end_info();
351 int flush_info(bool force = false);
353
354 bool shall_ignore_server_id(ulong s_id);
355
356 /*
357 A buffer to hold " for channel <channel_name>
358 used in error messages per channel
359 */
362
363 /**
364 @return The pointer to the Gtid_monitoring_info
365 */
368 }
369
370 /**
371 Stores the details of the transaction the receiver thread has just started
372 queueing.
373
374 @param gtid_arg the gtid of the trx
375 @param original_ts_arg the original commit timestamp of the transaction
376 @param immediate_ts_arg the immediate commit timestamp of the transaction
377 */
378 void started_queueing(Gtid gtid_arg, ulonglong original_ts_arg,
379 ulonglong immediate_ts_arg) {
380 gtid_monitoring_info->start(gtid_arg, original_ts_arg, immediate_ts_arg);
381 }
382
383 /**
384 When the receiver thread finishes queueing a transaction, that timestamp
385 is recorded and the information is copied to last_queued_trx and cleared
386 from queueing_trx.
387 */
389
390 /**
391 @return True if there is a transaction currently being queued
392 */
395 }
396
397 /**
398 @return The pointer to the GTID of the processing_trx of
399 Gtid_monitoring_info.
400 */
403 }
404
405 /**
406 Clears the processing_trx monitoring info.
407
408 Normally called when there is an error while queueing the transaction.
409 */
410 void clear_queueing_trx(bool need_lock = false) {
411 if (need_lock) mysql_mutex_lock(&data_lock);
413 if (need_lock) mysql_mutex_unlock(&data_lock);
414 }
415
416 /**
417 Clears all GTID monitoring info.
418 */
419 void clear_gtid_monitoring_info(bool need_lock = false) {
420 if (need_lock) mysql_mutex_lock(&data_lock);
422 if (need_lock) mysql_mutex_unlock(&data_lock);
423 }
424
425 ~Master_info() override;
426
427 /**
428 Sets the flag that indicates that a relay log rotation has been requested.
429
430 @param[in] thd the client thread carrying the command.
431 */
432 void request_rotate(THD *thd);
433 /**
434 Clears the flag that indicates that a relay log rotation has been requested
435 and notifies requester that the rotation has finished.
436 */
438 /**
439 Checks whether or not there is a request for rotating the underlying relay
440 log.
441
442 @returns true if there is, false otherwise
443 */
444 bool is_rotate_requested();
445
446 protected:
449
450 public:
451 inline const char *get_master_log_name() const { return master_log_name; }
452 inline const char *get_master_log_name_info() const {
453 if (m_is_receiver_position_info_invalid) return "INVALID";
454 return get_master_log_name();
455 }
456 inline ulonglong get_master_log_pos() const { return master_log_pos; }
459 return get_master_log_pos();
460 }
461 inline void set_master_log_name(const char *log_file_name) {
463 }
464 inline void set_master_log_pos(ulonglong log_pos) {
466 master_log_pos = log_pos;
467 }
468 inline const char *get_io_rpl_log_name() {
469 return (master_log_name[0] ? master_log_name : "FIRST");
470 }
471 static size_t get_number_info_mi_fields();
472
473 /**
474 returns the column number of a channel in the TABLE repository.
475 Mainly used during server startup to load the information required
476 from the slave repository tables. See rpl_info_factory.cc
477 */
479
480 /**
481 Returns an array with the expected column names of the primary key
482 fields of the table repository.
483 */
484 static const char **get_table_pk_field_names();
485
486 /**
487 Returns an array with the expected column numbers of the primary key
488 fields of the table repository.
489 */
490 static const uint *get_table_pk_field_indexes();
491
492 /**
493 Sets bits for columns that are allowed to be `NULL`.
494
495 @param nullable_fields the bitmap to hold the nullable fields.
496 */
497 static void set_nullable_fields(MY_BITMAP *nullable_fields);
498
500
501 void set_auto_position(bool auto_position_param) {
502 auto_position = auto_position_param;
503 }
504
505 /**
506 Checks if Asynchronous Replication Connection Failover feature is enabled.
507
508 @returns true if Asynchronous Replication Connection Failover feature is
509 enabled.
510 false otherwise.
511 */
514 }
515
516 /**
517 Enable Asynchronous Replication Connection Failover feature.
518 */
521 }
522
523 /**
524 Disable Asynchronous Replication Connection Failover feature.
525 */
528 }
529
530 /**
531 Return current position in the Failover source list for the
532 Asynchronous Replication Connection Failover feature.
533 Based on this position next failover source is selected.
534
535 @returns current position in the Failover source list.
536 */
538
539 /**
540 Reset current position to 0, when new failover source list is fetched.
541 */
543
544 /**
545 Increment current position, so next failover source can be selected on
546 failure.
547 */
549
550 /**
551 Checks if network error has occurred.
552
553 @returns true if slave IO thread failure was due to network error,
554 false otherwise.
555 */
557
558 /**
559 Sets m_network_error to true. Its used by async replication connection
560 failover in case of slave IO thread failure to check if it was due to
561 network failure.
562 */
564
565 /**
566 Resets m_network_error to false.
567 */
569
570 /**
571 This member function shall return true if there are server
572 ids configured to be ignored.
573
574 @return true if there are server ids to be ignored,
575 false otherwise.
576 */
578
579 private:
580 /**
581 Format_description_log_event for events received from the master
582 by the IO thread and written to the tail of the relay log.
583
584 Use patterns:
585 - Created when the IO thread starts and destroyed when the IO
586 thread stops.
587 - Updated when the IO thread receives a
588 Format_description_log_event.
589 - Accessed by the IO thread when it de-serializes events (e.g.,
590 rotate events, Gtid events).
591 - Written by the IO thread to the new relay log on every rotation.
592 - Written by a client that executes FLUSH LOGS to the new relay
593 log on every rotation.
594
595 Locks:
596 All access is protected by Relay_log::LOCK_log.
597 */
599
600 public:
604 }
609 }
610
611 bool set_info_search_keys(Rpl_info_handler *to) override;
612
613 const char *get_for_channel_str(bool upper_case = false) const override {
614 return reinterpret_cast<const char *>(upper_case ? for_channel_uppercase_str
616 }
617
618 void init_master_log_pos();
619
620 private:
621 bool read_info(Rpl_info_handler *from) override;
622 bool write_info(Rpl_info_handler *to) override;
623
624 bool auto_position{false};
627 bool m_network_error{false};
628
631 PSI_mutex_key *param_key_info_run_lock,
632 PSI_mutex_key *param_key_info_data_lock,
633 PSI_mutex_key *param_key_info_sleep_lock,
634 PSI_mutex_key *param_key_info_thd_lock,
635 PSI_mutex_key *param_key_info_rotate_lock,
636 PSI_mutex_key *param_key_info_data_cond,
637 PSI_mutex_key *param_key_info_start_cond,
638 PSI_mutex_key *param_key_info_stop_cond,
639 PSI_mutex_key *param_key_info_sleep_cond,
640 PSI_mutex_key *param_key_info_rotate_cond,
641#endif
642 uint param_id, const char *param_channel);
643
646
647 public:
648 /*
649 This will be used to verify transactions boundaries of events sent by the
650 master server.
651 It will also be used to verify transactions boundaries on the relay log
652 while collecting the Retrieved_Gtid_Set to make sure of only adding GTIDs
653 of fully retrieved transactions.
654 Its output is also used to detect when events were not logged using row
655 based logging.
656 */
658
659 private:
660 /*
661 This is the channel lock. It is a rwlock used to serialize all replication
662 administrative commands that cannot be performed concurrently for a given
663 replication channel:
664 - START SLAVE;
665 - STOP SLAVE;
666 - CHANGE MASTER;
667 - RESET SLAVE;
668 - end_slave() (when mysqld stops)).
669 Any of these commands must hold the wrlock from the start till the end.
670 */
672
673 /* References of the channel, the channel can only be deleted when it is 0. */
674 std::atomic<int32> atomic_references{0};
675
676 public:
677 /**
678 Acquire the channel read lock.
679 */
680 void channel_rdlock();
681
682 /**
683 Acquire the channel write lock.
684 */
685 void channel_wrlock();
686
687 /**
688 Try to acquire the write lock, and fail if it cannot be
689 immediately granted.
690 */
691 int channel_trywrlock();
692
693 /**
694 Release the channel lock (whether it is a write or read lock).
695 */
697
698 /**
699 Assert that some thread holds either the read or the write lock.
700 */
701 inline void channel_assert_some_lock() const {
703 }
704
705 /**
706 Assert that some thread holds the write lock.
707 */
708 inline void channel_assert_some_wrlock() const {
710 }
711
712 /**
713 Increase the reference count to prohibit deleting a channel. This function
714 must be protected by channel_map.rdlock(). dec_reference has to be
715 called in conjunction with inc_reference().
716 */
718
719 /**
720 Decrease the reference count. Doesn't need the protection of
721 channel_map.rdlock.
722 */
724
725 /**
726 It mush be called before deleting a channel and protected by
727 channel_map_lock.wrlock().
728
729 @param thd the THD object of current thread
730 */
731 void wait_until_no_reference(THD *thd);
732
733 /* Set true when the Master_info object was cleared by a RESET SLAVE */
734 bool reset;
735
736 /**
737 Sync flushed_relay_log_info with current relay log coordinates.
738
739 It will sync the receiver thread relay log coordinates (file name and
740 position) with the last master coordinates that were flushed into the
741 Master_info repository.
742
743 This function shall be called by Master_info::flush_info() at the end of a
744 successful flush of the Master_info content into the repository while still
745 holding the data_lock.
746
747 It is also called my load_mi_and_rli_from_repositories(), right after the
748 successful call to rli_init_info() that opens the relay log.
749 */
750
752
753 /**
754 Collect relay log coordinates (file name and position) that related to the
755 last Master_info master coordinates flushed into the repository.
756
757 @param [out] linfo Where the relay log coordinates shall be stored.
758 */
759
761
762 /**
763 Marks the receiver position information (master_log_name, master_log_pos)
764 as being invalid or not.
765
766 @param invalid The value to set the status to invalid or valid
767 */
768 void set_receiver_position_info_invalid(bool invalid);
769
770 /**
771 Returns if receiver position information is valid or invalid
772
773 @return true if receiver position information is not reliable,
774 false otherwise.
775 */
777
778 /**
779 Enable or disable the gtid_only mode
780
781 @param gtid_only_mode value to set gtid_only (enable/disable it)
782 */
783 void set_gtid_only_mode(bool gtid_only_mode);
784
785 /**
786 Returns if gtid_only is enabled or not
787
788 @return true if gtid_only mode is active for a channel,
789 false otherwise.
790 */
791 bool is_gtid_only_mode() const;
792
793 private:
794 /*
795 Holds the relay log coordinates (file name and position) of the last master
796 coordinates flushed into Master_info repository.
797 */
799
800 /**
801 Is the replica working in GTID only mode, meaning it does not
802 persist position related information when executing or queueing transactions.
803 */
805
806 /**
807 Are positions invalid. When true this means the values for
808 receiver position related information might be outdated.
809 */
811};
812
813#endif /* RPL_MI_H */
Contains the classes representing events occurring in the replication stream.
This has the functionality of mysql_rwlock_t, with two differences:
Definition: rpl_gtid.h:308
void assert_some_lock() const
Assert that some thread holds either the read or the write lock.
Definition: rpl_gtid.h:545
void unlock()
Release the lock (whether it is a write or read lock).
Definition: rpl_gtid.h:479
void assert_some_wrlock() const
Assert that some thread holds the write lock.
Definition: rpl_gtid.h:549
For binlog version 4.
Definition: log_event.h:1613
Stores information to monitor a transaction during the different replication stages.
Definition: rpl_gtid.h:1310
const Gtid * get_processing_trx_gtid()
Returns the GTID of the processing_trx.
Definition: rpl_gtid_misc.cc:525
void clear()
Clear all monitoring information.
Definition: rpl_gtid_misc.cc:419
void finish()
Sets the final information, copy processing info to last_processed and clears processing info.
Definition: rpl_gtid_misc.cc:486
void start(Gtid gtid_arg, ulonglong original_ts_arg, ulonglong immediate_ts_arg, bool skipped_arg=false)
Sets the initial monitoring information.
Definition: rpl_gtid_misc.cc:446
bool is_processing_trx_set()
Returns true if the processing_trx is set, false otherwise.
Definition: rpl_gtid_misc.cc:516
void clear_processing_trx()
Clear only the processing_trx monitoring info.
Definition: rpl_gtid_misc.cc:426
mysql_mutex_t * get_log_lock()
Definition: binlog.h:864
Definition: rpl_mi.h:86
static const uint * get_table_pk_field_indexes()
Returns an array with the expected column numbers of the primary key fields of the table repository.
Definition: rpl_mi.cc:447
Gtid_monitoring_info * gtid_monitoring_info
Information on the current and last queued transactions.
Definition: rpl_mi.h:137
size_t get_user_size() const
Returns user's size name.
Definition: rpl_mi.h:218
void set_password(const char *password_arg)
Stores either user's password in the master.info repository when CHANGE MASTER is executed or user's ...
Definition: rpl_mi.cc:721
bool start_user_configured
If true, USER/PASSWORD was specified when running START SLAVE.
Definition: rpl_mi.h:109
char network_namespace[NAME_LEN]
Definition: rpl_mi.h:334
bool m_gtid_only_mode
Is the replica working in GTID only mode, meaning it does not persist position related information wh...
Definition: rpl_mi.h:804
bool is_rotate_requested()
Checks whether or not there is a request for rotating the underlying relay log.
Definition: rpl_mi.cc:306
Relay_log_info * rli
Definition: rpl_mi.h:298
void end_info()
Definition: rpl_mi.cc:337
bool is_gtid_only_mode() const
Returns if gtid_only is enabled or not.
Definition: rpl_mi.cc:816
void set_master_log_pos(ulonglong log_pos)
Definition: rpl_mi.h:464
binary_log::enum_binlog_checksum_alg checksum_alg_before_fd
Definition: rpl_mi.h:325
char public_key_path[FN_REFLEN]
Definition: rpl_mi.h:292
char start_plugin_auth[FN_REFLEN+1]
Stores the authentication plugin specified when running START SLAVE.
Definition: rpl_mi.h:129
int mi_init_info()
Creates or reads information from the repository, initializing the Master_info.
Definition: rpl_mi.cc:407
void inc_reference()
Increase the reference count to prohibit deleting a channel.
Definition: rpl_mi.h:717
void increment_failover_list_position()
Increment current position, so next failover source can be selected on failure.
Definition: rpl_mi.h:548
long clock_diff_with_master
Definition: rpl_mi.h:311
char master_uuid[UUID_LENGTH+1]
Definition: rpl_mi.h:327
char start_password[MAX_PASSWORD_LENGTH+1]
Password specified when running START SLAVE.
Definition: rpl_mi.h:125
void set_plugin_auth(const char *src)
Stores the DEFAULT_AUTH defined by START SLAVE.
Definition: rpl_mi.h:268
void set_receiver_position_info_invalid(bool invalid)
Marks the receiver position information (master_log_name, master_log_pos) as being invalid or not.
Definition: rpl_mi.cc:804
Gtid_monitoring_info * get_gtid_monitoring_info()
Definition: rpl_mi.h:366
void set_master_log_name(const char *log_file_name)
Definition: rpl_mi.h:461
static uint get_channel_field_num()
returns the column number of a channel in the TABLE repository.
Definition: rpl_mi.cc:442
void reset_network_error()
Resets m_network_error to false.
Definition: rpl_mi.h:568
const char * get_for_channel_str(bool upper_case=false) const override
Definition: rpl_mi.h:613
const char * get_user() const
If an user was specified when running START SLAVE, this function returns such user.
Definition: rpl_mi.h:227
static const char ** get_table_pk_field_names()
Returns an array with the expected column names of the primary key fields of the table repository.
NET_SERVER server_extn
Definition: rpl_mi.h:347
bool set_info_search_keys(Rpl_info_handler *to) override
To search in the slave repositories, each slave info object (mi, rli or worker) should use a primary ...
Definition: rpl_mi.cc:678
void set_source_connection_auto_failover()
Enable Asynchronous Replication Connection Failover feature.
Definition: rpl_mi.h:519
my_off_t master_log_pos
Definition: rpl_mi.h:448
Checkable_rwlock * m_channel_lock
Definition: rpl_mi.h:671
void set_user(const char *user_arg)
Sets either user's name in the master.info repository when CHANGE MASTER is executed or user's name u...
Definition: rpl_mi.h:206
void request_rotate(THD *thd)
Sets the flag that indicates that a relay log rotation has been requested.
Definition: rpl_mi.cc:265
char compression_algorithm[COMPRESSION_ALGORITHM_NAME_BUFFER_SIZE]
Definition: rpl_mi.h:345
bool is_source_connection_auto_failover()
Checks if Asynchronous Replication Connection Failover feature is enabled.
Definition: rpl_mi.h:512
const char * get_start_plugin_dir()
Returns the PLUGIN_DIR defined by START SLAVE.
Definition: rpl_mi.h:264
bool is_set_network_namespace() const
Definition: rpl_mi.h:336
void reset_failover_list_position()
Reset current position to 0, when new failover source list is fetched.
Definition: rpl_mi.h:542
void clear_gtid_monitoring_info(bool need_lock=false)
Clears all GTID monitoring info.
Definition: rpl_mi.h:419
uint connect_retry
Definition: rpl_mi.h:300
bool is_network_error()
Checks if network error has occurred.
Definition: rpl_mi.h:556
char for_channel_uppercase_str[CHANNEL_NAME_LENGTH+31]
Definition: rpl_mi.h:361
bool auto_position
Definition: rpl_mi.h:624
void clear_rotate_requests()
Clears the flag that indicates that a relay log rotation has been requested and notifies requester th...
Definition: rpl_mi.cc:285
bool ssl
Definition: rpl_mi.h:278
void set_gtid_only_mode(bool gtid_only_mode)
Enable or disable the gtid_only mode.
Definition: rpl_mi.cc:812
uint m_failover_list_position
Definition: rpl_mi.h:626
void channel_rdlock()
Acquire the channel read lock.
Definition: rpl_mi.cc:757
char ssl_capath[FN_REFLEN]
Definition: rpl_mi.h:279
void reset_start_info()
Cleans in-memory password defined by START SLAVE.
Definition: rpl_mi.cc:748
std::pair< bool, std::string > tls_ciphersuites
Definition: rpl_mi.h:290
Replication_transaction_boundary_parser transaction_parser
Definition: rpl_mi.h:657
void set_auto_position(bool auto_position_param)
Definition: rpl_mi.h:501
static bool is_configured(Master_info *mi)
Definition: rpl_mi.h:103
bool get_password(char *password_arg, size_t *password_arg_size)
Returns either user's password in the master.info repository or user's password used in START SLAVE.
Definition: rpl_mi.cc:732
void set_mi_description_event(Format_description_log_event *fdle)
Definition: rpl_mi.h:605
Format_description_log_event * get_mi_description_event()
Definition: rpl_mi.h:601
void dec_reference()
Decrease the reference count.
Definition: rpl_mi.h:723
char master_log_name[FN_REFLEN]
Definition: rpl_mi.h:447
bool is_ignore_server_ids_configured()
This member function shall return true if there are server ids configured to be ignored.
Definition: rpl_mi.cc:783
void channel_wrlock()
Acquire the channel write lock.
Definition: rpl_mi.cc:762
void update_flushed_relay_log_info()
Sync flushed_relay_log_info with current relay log coordinates.
Definition: rpl_mi.cc:787
ulonglong last_heartbeat
Definition: rpl_mi.h:315
bool read_info(Rpl_info_handler *from) override
Definition: rpl_mi.cc:459
bool ssl_verify_server_cert
Definition: rpl_mi.h:293
uint32 file_id
Definition: rpl_mi.h:297
int flush_info(bool force=false)
Store the master file and position where the slave's I/O thread are in the relay log.
Definition: rpl_mi.cc:366
bool m_network_error
Definition: rpl_mi.h:627
void wait_until_no_reference(THD *thd)
It mush be called before deleting a channel and protected by channel_map_lock.wrlock().
Definition: rpl_mi.cc:772
std::atomic< int32 > atomic_references
Definition: rpl_mi.h:674
static void set_nullable_fields(MY_BITMAP *nullable_fields)
Sets bits for columns that are allowed to be NULL.
Definition: rpl_mi.cc:451
bool reset
Definition: rpl_mi.h:734
void channel_unlock()
Release the channel lock (whether it is a write or read lock).
Definition: rpl_mi.h:696
PSI_mutex_key * key_info_rotate_cond
PSI key for the rotate_cond
Definition: rpl_mi.h:147
LOG_INFO flushed_relay_log_info
Definition: rpl_mi.h:798
ulong master_id
Definition: rpl_mi.h:319
void set_relay_log_info(Relay_log_info *info)
Definition: rpl_mi.cc:401
char ssl_key[FN_REFLEN]
Definition: rpl_mi.h:280
bool m_is_receiver_position_info_invalid
Are positions invalid.
Definition: rpl_mi.h:810
const char * get_io_rpl_log_name()
Definition: rpl_mi.h:468
const Gtid * get_queueing_trx_gtid()
Definition: rpl_mi.h:401
PSI_mutex_key * key_info_rotate_lock
PSI key for the rotate_lock
Definition: rpl_mi.h:143
MYSQL * mysql
Definition: rpl_mi.h:296
ulonglong received_heartbeats
Definition: rpl_mi.h:313
char host[HOSTNAME_LENGTH+1]
Host name or ip address stored in the master.info.
Definition: rpl_mi.h:93
char user[USERNAME_LENGTH+1]
User's name stored in the master.info.
Definition: rpl_mi.h:113
const char * get_master_log_name_info() const
Definition: rpl_mi.h:452
char ssl_crl[FN_REFLEN]
Definition: rpl_mi.h:291
char ssl_cipher[FN_REFLEN]
Definition: rpl_mi.h:280
char ssl_ca[FN_REFLEN]
Definition: rpl_mi.h:279
bool is_start_plugin_auth_configured() const
Returns if DEFAULT_AUTH was specified when running START SLAVE.
Definition: rpl_mi.h:179
uint get_failover_list_position()
Return current position in the Failover source list for the Asynchronous Replication Connection Failo...
Definition: rpl_mi.h:537
Master_info(PSI_mutex_key *param_key_info_run_lock, PSI_mutex_key *param_key_info_data_lock, PSI_mutex_key *param_key_info_sleep_lock, PSI_mutex_key *param_key_info_thd_lock, PSI_mutex_key *param_key_info_rotate_lock, PSI_mutex_key *param_key_info_data_cond, PSI_mutex_key *param_key_info_start_cond, PSI_mutex_key *param_key_info_stop_cond, PSI_mutex_key *param_key_info_sleep_cond, PSI_mutex_key *param_key_info_rotate_cond, uint param_id, const char *param_channel)
Definition: rpl_mi.cc:157
void channel_assert_some_wrlock() const
Assert that some thread holds the write lock.
Definition: rpl_mi.h:708
char tls_version[FN_REFLEN]
Definition: rpl_mi.h:281
char bind_addr[HOSTNAME_LENGTH+1]
Definition: rpl_mi.h:328
mysql_cond_t rotate_cond
Waiting condition that will block the process/thread requesting a relay log rotation in the middle of...
Definition: rpl_mi.h:160
void set_start_user_configured(bool config)
Defines that USER/PASSWORD was specified or not when running START SLAVE.
Definition: rpl_mi.h:196
ulonglong get_master_log_pos() const
Definition: rpl_mi.h:456
Server_ids * ignore_server_ids
Definition: rpl_mi.h:317
bool is_auto_position()
Definition: rpl_mi.h:499
bool is_start_user_configured() const
Returns if USER/PASSWORD was specified when running START SLAVE.
Definition: rpl_mi.h:173
char for_channel_str[CHANNEL_NAME_LENGTH+31]
Definition: rpl_mi.h:360
~Master_info() override
Definition: rpl_mi.cc:248
char ssl_crlpath[FN_REFLEN]
Definition: rpl_mi.h:291
char start_user[USERNAME_LENGTH+1]
User specified when running START SLAVE.
Definition: rpl_mi.h:121
bool is_receiver_position_info_invalid() const
Returns if receiver position information is valid or invalid.
Definition: rpl_mi.cc:808
bool shall_ignore_server_id(ulong s_id)
Reports if the s_id server has been configured to ignore events it generates with.
Definition: rpl_mi.cc:323
const char * network_namespace_str() const
Definition: rpl_mi.h:338
void channel_assert_some_lock() const
Assert that some thread holds either the read or the write lock.
Definition: rpl_mi.h:701
ulong retry_count
Definition: rpl_mi.h:326
bool write_info(Rpl_info_handler *to) override
Definition: rpl_mi.cc:686
void clear_queueing_trx(bool need_lock=false)
Clears the processing_trx monitoring info.
Definition: rpl_mi.h:410
void set_network_error()
Sets m_network_error to true.
Definition: rpl_mi.h:563
void finished_queueing()
When the receiver thread finishes queueing a transaction, that timestamp is recorded and the informat...
Definition: rpl_mi.h:388
char start_plugin_dir[FN_REFLEN+1]
Stores the authentication plugin directory specified when running START SLAVE.
Definition: rpl_mi.h:134
int zstd_compression_level
Definition: rpl_mi.h:346
Master_info(const Master_info &info)
char ssl_cert[FN_REFLEN]
Definition: rpl_mi.h:279
std::atomic< bool > rotate_requested
If a rotate was requested while the relay log was in a transaction.
Definition: rpl_mi.h:164
mysql_mutex_t rotate_lock
Lock to protect from rotating the relay log when in the middle of a transaction.
Definition: rpl_mi.h:153
bool m_source_connection_auto_failover
Definition: rpl_mi.h:625
bool get_public_key
Definition: rpl_mi.h:294
ulonglong get_master_log_pos_info() const
Definition: rpl_mi.h:457
void started_queueing(Gtid gtid_arg, ulonglong original_ts_arg, ulonglong immediate_ts_arg)
Stores the details of the transaction the receiver thread has just started queueing.
Definition: rpl_mi.h:378
float heartbeat_period
Definition: rpl_mi.h:312
static size_t get_number_info_mi_fields()
Definition: rpl_mi.cc:438
Master_info & operator=(const Master_info &info)
uint port
Definition: rpl_mi.h:299
bool is_queueing_trx()
Definition: rpl_mi.h:393
void get_flushed_relay_log_info(LOG_INFO *linfo)
Collect relay log coordinates (file name and position) that related to the last Master_info master co...
Definition: rpl_mi.cc:798
int channel_trywrlock()
Try to acquire the write lock, and fail if it cannot be immediately granted.
Definition: rpl_mi.cc:767
const char * get_master_log_name() const
Definition: rpl_mi.h:451
Format_description_log_event * mi_description_event
Format_description_log_event for events received from the master by the IO thread and written to the ...
Definition: rpl_mi.h:598
bool is_start_plugin_dir_configured() const
Returns if PLUGIN_DIR was specified when running START SLAVE.
Definition: rpl_mi.h:187
void init_master_log_pos()
Definition: rpl_mi.cc:328
void set_plugin_dir(const char *src)
Stores the DEFAULT_AUTH defined by START SLAVE.
Definition: rpl_mi.h:274
char password[MAX_PASSWORD_LENGTH+1]
User's password stored in the master.info.
Definition: rpl_mi.h:117
void unset_source_connection_auto_failover()
Disable Asynchronous Replication Connection Failover feature.
Definition: rpl_mi.h:526
const char * get_start_plugin_auth()
Returns the DEFAULT_AUTH defined by START SLAVE.
Definition: rpl_mi.h:258
Definition: rpl_rli.h:201
MYSQL_BIN_LOG relay_log
Definition: rpl_rli.h:328
This is the class for verifying transaction boundaries in a replication event stream.
Definition: rpl_trx_boundary_parser.h:50
Definition: rpl_info_factory.h:43
Definition: rpl_info_handler.h:57
Definition: rpl_info.h:42
mysql_mutex_t data_lock
Definition: rpl_info.h:57
Definition: dynamic_ids.h:32
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_class.h:922
#define mysql_mutex_lock(M)
Definition: mysql_mutex.h:49
#define mysql_mutex_unlock(M)
Definition: mysql_mutex.h:56
#define COMPRESSION_ALGORITHM_NAME_BUFFER_SIZE
Definition: compression.h:41
unsigned int PSI_mutex_key
Instrumented mutex key.
Definition: psi_mutex_bits.h:51
#define mysql_mutex_assert_owner(M)
Wrapper, to use safe_mutex_assert_owner with instrumented mutexes.
Definition: mysql_mutex.h:111
std::string log_file_name(const Log_files_context &ctx, Log_file_id file_id)
Provides name of the log file with the given file id, e.g.
Definition: log0files_io.cc:720
Binary log event definitions.
char * strmake(char *dst, const char *src, size_t length)
Definition: strmake.cc:42
static constexpr int HOSTNAME_LENGTH
Definition: my_hostname.h:42
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
ulonglong my_off_t
Definition: my_inttypes.h:71
uint32_t uint32
Definition: my_inttypes.h:66
Common #defines and includes for file and socket I/O.
#define FN_REFLEN
Definition: my_io.h:82
Defines various enable/disable and HAVE_ macros related to the performance schema instrumentation sys...
#define HAVE_PSI_INTERFACE
Definition: my_psi_config.h:38
Common definition between mysql server & client.
#define NAME_LEN
Definition: mysql_com.h:66
#define USERNAME_LENGTH
Definition: mysql_com.h:68
Log info(cout, "NOTE")
enum_binlog_checksum_alg
Enumeration spcifying checksum algorithm used to encode a binary log event.
Definition: binlog_event.h:412
Instrumentation helpers for mutexes.
Instrumentation helpers for mutexes.
#define CHANNEL_NAME_LENGTH
Definition: rpl_info.h:40
Replication transaction boundary parser.
File containing constants that can be used throughout the server.
constexpr const size_t UUID_LENGTH
Definition: sql_const.h:269
TODO: Move this structure to libbinlogevents/include/control_events.h when we start using C++11.
Definition: rpl_gtid.h:1065
Definition: binlog.h:117
Definition: mysql.h:298
Definition: my_bitmap.h:42
Definition: mysql_com_server.h:58
An instrumented cond structure.
Definition: mysql_cond_bits.h:49
An instrumented mutex structure.
Definition: mysql_mutex_bits.h:49
Include file for Sun RPC to compile out of the box.
unsigned int uint
Definition: uca-dump.cc:29
#define MAX_PASSWORD_LENGTH
Definition: validate_password.cc:63