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