MySQL  8.0.27
Source Code Documentation
rpl_mi.h
Go to the documentation of this file.
1 /* Copyright (c) 2006, 2021, 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"
37 #include "mysql/psi/mysql_mutex.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 
47 class Rpl_info_handler;
48 class Server_ids;
49 class THD;
50 struct 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 
86 class 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  */
93  char host[HOSTNAME_LENGTH + 1];
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 autentication plugin specified when running START SLAVE.
128  */
130  /**
131  Stores the autentication 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 
319  ulong master_id;
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  */
326  ulong retry_count;
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  */
367  return gtid_monitoring_info;
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  */
437  void clear_rotate_requests();
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) {
462  strmake(master_log_name, log_file_name, sizeof(master_log_name) - 1);
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 repostiory tables. See rpl_info_factory.cc
477  */
478  static uint get_channel_field_num();
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 
499  bool is_auto_position() { return auto_position; }
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:
603  return mi_description_event;
604  }
607  delete mi_description_event;
608  mi_description_event = fdle;
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
615  : for_channel_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 
629  Master_info(
630 #ifdef HAVE_PSI_INTERFACE
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  */
696  inline void channel_unlock() { m_channel_lock->unlock(); }
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 queing 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:306
void assert_some_lock() const
Assert that some thread holds either the read or the write lock.
Definition: rpl_gtid.h:527
void unlock()
Release the lock (whether it is a write or read lock).
Definition: rpl_gtid.h:461
void assert_some_wrlock() const
Assert that some thread holds the write lock.
Definition: rpl_gtid.h:531
For binlog version 4.
Definition: log_event.h:1613
Stores information to monitor a transaction during the different replication stages.
Definition: rpl_gtid.h:1291
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:831
Definition: rpl_mi.h:86
const Gtid * get_queueing_trx_gtid()
Definition: rpl_mi.h:401
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 autentication 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
const char * get_for_channel_str(bool upper_case=false) const override
Definition: rpl_mi.h:613
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
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
Gtid_monitoring_info * get_gtid_monitoring_info()
Definition: rpl_mi.h:366
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
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
const char * get_start_plugin_dir()
Returns the PLUGIN_DIR defined by START SLAVE.
Definition: rpl_mi.h:264
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
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.
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
const char * network_namespace_str() const
Definition: rpl_mi.h:338
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
const char * get_user() const
If an user was specified when running START SLAVE, this function returns such user.
Definition: rpl_mi.h:227
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
Master_info & operator=(const Master_info &info)
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
const char * get_start_plugin_auth()
Returns the DEFAULT_AUTH defined by START SLAVE.
Definition: rpl_mi.h:258
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
Format_description_log_event * get_mi_description_event()
Definition: rpl_mi.h:601
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
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
const char * get_io_rpl_log_name()
Definition: rpl_mi.h:468
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
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 autentication 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
const char * get_master_log_name_info() const
Definition: rpl_mi.h:452
static size_t get_number_info_mi_fields()
Definition: rpl_mi.cc:438
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
Definition: rpl_rli.h:200
MYSQL_BIN_LOG relay_log
Definition: rpl_rli.h:327
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:821
#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
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:411
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.
#define UUID_LENGTH
Definition: sql_const.h:411
TODO: Move this structure to libbinlogevents/include/control_events.h when we start using C++11.
Definition: rpl_gtid.h:1047
Definition: binlog.h:116
Definition: mysql.h:297
Definition: my_bitmap.h:41
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
const int MAX_PASSWORD_LENGTH
Definition: validate_password_imp.cc:43