MySQL  8.0.22
Source Code Documentation
gcs_xcom_state_exchange.h
Go to the documentation of this file.
1 /* Copyright (c) 2015, 2020, 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 GCS_XCOM_STATE_EXCHANGE_INCLUDED
24 #define GCS_XCOM_STATE_EXCHANGE_INCLUDED
25 
26 #include <stdio.h>
27 #include <sys/types.h>
28 #include <map>
29 #include <memory> // std::unique_ptr
30 #include <set>
31 #include <string>
32 #include <vector>
33 
43 #include "plugin/group_replication/libmysqlgcs/xdr_gen/xcom_vp.h"
44 
45 /**
46  @class Xcom_member_state
47 
48  Class that conveys the state to be exchanged between members, which is not
49  provided by XCom.
50 
51  In the original GCS protocol (version 1), this message had the following wire
52  format:
53 
54  +--------+---------------------+
55  | Header | Upper-layer payload |
56  +--------+---------------------+
57 
58  Where the header has the following format:
59 
60  +---------+------------+
61  | View ID | XCom synod |
62  +---------+------------+
63 
64  With the introduction of the fragmentation stage into the message pipeline, it
65  is possible that an original message is fragmented into several fragments, and
66  each fragment is delivered by XCom individually.
67 
68  This means that when a node joins, it is possible for the transmission of a
69  fragmented message to be ongoing, i.e. the existing group members have already
70  received some, but not all, of the fragments.
71  In this situation, the last fragment will arrive after the new node has joined
72  the group.
73  Since the original message is only delivered when all its fragments are
74  received, this means that the original message will need to be delivered by
75  the new node as well.
76  But the problem is that new node does not have the fragments that were
77  received before the new node joined.
78 
79  We solve this problem by augmenting the state exchange message with
80  information about the ongoing transmission of fragmented messages.
81  In particular, for every fragmented message whose transmission is ongoing, a
82  node will attach the XCom synods of the fragments it has already received.
83  The new node can use this information to fetch the fragments from XCom.
84 
85  As such, in GCS protocol version 2, this message has the following wire
86  format:
87 
88  +--------+---------------------+----------------+
89  | Header | Upper-layer payload | Recovery info. |
90  +--------+---------------------+----------------+
91 
92  Where the recovery information has the following format:
93 
94  +---------------+-...-+----------------+------------+
95  | XCom synod #1 | | XCom synode #n | Nr. synods |
96  +---------------+-...-+----------------+------------+
97 
98  Older GCS instances that only support protocol version 1 will deserialize the
99  recovery information as part of the upper-layer payload.
100  However, this works as long as the upper layer consumes only the portion it is
101  expecting (upper-layer payload), even though it is fed its expected payload
102  with the recovery information appended.
103 */
105  public:
106  /**
107  Xcom_member_state constructor.
108 
109  @param[in] view_id the view identifier from the node
110  @param[in] configuration_id Configuration identifier in use when the state
111  exchange message was created
112  @param[in] version Protocol version used to represent the state
113  @param[in] snapshot Snapshot information currently in use
114  @param[in] data the generic data to be exchanged
115  @param[in] data_size data's size
116  */
117 
118  explicit Xcom_member_state(const Gcs_xcom_view_identifier &view_id,
119  synode_no configuration_id,
121  const Gcs_xcom_synode_set &snapshot,
122  const uchar *data, uint64_t data_size);
123 
124  /**
125  Xcom_member_state constructor.
126 
127  @param[in] version Protocol version used to represent the state
128  @param[in] data the generic data to be exchanged
129  @param[in] data_size data's size
130  */
131 
132  explicit Xcom_member_state(Gcs_protocol_version version, const uchar *data,
133  uint64_t data_size);
134 
135  /**
136  Member state destructor.
137  */
138 
140 
141  /**
142  Encodes the Member State's header to be sent through the newtwork.
143 
144  @param[out] buffer where the header will be stored.
145  @param[in,out] buffer_len pointer to the variable that will hold the
146  header's size and has the buffer's len as input.
147 
148  @return True if there is no space to store the header.
149  Otherwise, false.
150  */
151  bool encode_header(uchar *buffer, uint64_t *buffer_len) const;
152 
153  /**
154  Decodes the Member State's header that was sent through the network.
155 
156  @param[out] buffer Where the header was stored.
157  @param[in,out] buffer_len Pointer to the variable that holds the
158  header's size and has the buffer's len as input.
159 
160  @return true if nothing went wrong. Otherwise, false.
161  */
162  bool decode_header(const uchar *buffer, uint64_t buffer_len);
163 
164  /**
165  Encodes the Member State's snapshot to be sent through the network.
166 
167  @param[out] buffer where the snapshot will be stored.
168  @param[in,out] buffer_len pointer to the variable that will hold the
169  snapshot's size and has the buffer's len as input.
170 
171  @return True if there is no space to store the snapshot.
172  Otherwise, false.
173  */
174  bool encode_snapshot(uchar *buffer, uint64_t *buffer_len) const;
175 
176  /**
177  Decodes the Member State's snapshot that was sent through the network.
178 
179  @param[out] buffer Where the snapshot was stored.
180  @param[in,out] buffer_len It holds the snapshot's size.
181 
182  @return true if nothing went wrong. Otherwise, false.
183  */
184  bool decode_snapshot(const uchar *buffer, uint64_t buffer_len);
185 
186  /**
187  Decodes Member State that was sent through the network.
188 
189  @param[out] data where the data was stored.
190  @param[out] data_size pointer to the variable that holds the
191  data's size.
192 
193  @return True if for any reason the data could not be exchanged.
194  Otherwise, false.
195  */
196  bool decode(const uchar *data, uint64_t data_size);
197 
198  /**
199  @return the size of the encoded payload when put on the wire.
200  */
201 
202  uint64_t get_encode_payload_size() const;
203 
204  /**
205  @return the size of the encoded header when put on the wire.
206  */
207 
208  static constexpr uint64_t get_encode_header_size() {
212  }
213 
214  /**
215  @return the size of the encoded snapshot when put on the wire.
216  */
217 
218  uint64_t get_encode_snapshot_size() const;
219 
220  /**
221  @return the view identifier
222  */
223 
225 
226  /**
227  @return the configuration identifier
228  */
229 
230  synode_no get_configuration_id() const { return m_configuration_id; }
231 
232  /**
233  @return the generic exchangeable data
234  */
235 
236  const uchar *get_data() const { return m_data; }
237 
238  /**
239  @return the size of the generic exchangeable data
240  */
241 
242  uint64_t get_data_size() const { return m_data_size; }
243 
244  const Gcs_xcom_synode_set &get_snapshot() const { return m_snapshot; }
245 
246  private:
247  static constexpr auto WIRE_XCOM_VARIABLE_VIEW_ID_SIZE = 8;
248  static constexpr auto WIRE_XCOM_VIEW_ID_SIZE = 4;
249  static constexpr auto WIRE_XCOM_GROUP_ID_SIZE = 4;
250  static constexpr auto WIRE_XCOM_MSG_ID_SIZE = 8;
251  static constexpr auto WIRE_XCOM_NODE_ID_SIZE = 4;
252  static constexpr auto WIRE_XCOM_SNAPSHOT_NR_ELEMS_SIZE = 8;
253 
254  static constexpr uint64_t get_encode_snapshot_elem_size() {
255  return WIRE_XCOM_MSG_ID_SIZE + WIRE_XCOM_NODE_ID_SIZE;
256  }
257 
258  /*
259  View identifier installed by the current member if there
260  is any.
261  */
263 
264  /*
265  Configuration identifier in use when the state exchange message
266  was created.
267  */
269 
270  /*
271  Data to be disseminated by the state exchange phase.
272  */
274 
275  /*
276  Data's size disseminated by the state exchange phase.
277  */
278  uint64_t m_data_size;
279 
280  /**
281  Recovery information which is currently a list of the XCom synods of the
282  fragments that are in buffers when a node is joining.
283 
284  This is currently used only to transfer information on slice packets that
285  need to be fetched by the joining node before it may become ready to serve
286  requests.
287  */
289 
290  /**
291  GCS communication version number in use.
292  */
294 
295  /*
296  Disabling the copy constructor and assignment operator.
297  */
298  Xcom_member_state(Xcom_member_state const &) = delete;
299  Xcom_member_state &operator=(Xcom_member_state const &) = delete;
300 };
301 
302 /**
303  @class gcs_xcom_state_exchange_interface
304 
305  Interface that defines the operations that state exchange will provide.
306  In what follows, we describe how the state exchange algorithm works and
307  the view change process where it is inserted and which is an essential
308  part of our system.
309 
310  The view change process is comprised of two major parts:
311  - Adding or removing a node from the system, accomplished in the
312  XCom/Paxos layer: "The SMART Way to Migrate Replicated Stateful
313  Services"
314 
315  - A state exchange phase in which all members distribute data among
316  themselves.
317 
318  Whenever a node wants to add or remove itself from the group, or after
319  a failure when a healthy member expels the faulty node from the group, a
320  reconfiguration request is sent in the form of an add_node or remove_node
321  message.
322 
323  After the success of the request, XCOM sends a global view message
324  that contains information on all nodes tagging them as alive or
325  faulty to all non-faulty members. MySQL GCS looks at this information
326  and computes who has joined and who has left the group. The computation
327  is trivially simple and compares the set of nodes received in the
328  current view with the set of nodes in the previous view:
329 
330  . left nodes = (alive_members in old_set) - (alive_members in new_set)
331 
332  . joined nodes = (alive_members in new_set) - (alive_members in old_set)
333 
334  However, the new view is only delivered to an upper layer after all
335  members exchange what we call a state message. While the view is being
336  processed and the state exchange is ongoing, all incoming data messages
337  are not delivered to the application and are put into a buffer. So after
338  getting state messages from all members, the view change is delivered
339  to the upper layer along with the content of the state messages and any
340  buffered message is delivered afterwards.
341 
342  Why blocking the delivery of data messages and why these state
343  messages?
344 
345  Recall that all messages are atomically delivered and we can guarantee
346  that all nodes will have the same state which encompasses messages
347  (e.g. transactions) in queues and in the storage (e.g. binary log)
348  because all new data messages are buffered while the state messages
349  are being exchanged.
350 
351  Blocking the delivery of new data messages give us a synchronization
352  point.
353 
354  But if all nodes have the same state why gathering a state message
355  from all members?
356 
357  The power of choice. Let us use MySQL Group Replication as a concrete
358  example of an upper layer to understand why. This is done because having
359  information on all members allow the new node to choose a member that is
360  not lagging behind (i.e. has a small queue) as a donor in a recovery
361  phase. Besides, the state message also carries information on IPs and
362  Ports used to access the MySQL Instances. This information is necessary
363  to start the recovery which will be asynchronously started and will dump
364  the missing data from a donor.
365 
366  Note that the content of the state message is opaque to the MySQL GCS
367  layer which only provides a synchronization point.
368 */
370  public:
372 
373  /**
374  Accomplishes all necessary initialization steps.
375  */
376 
377  virtual void init() = 0;
378 
379  /**
380  If messages were buffered during its processing, they are discarded
381  and internal structures needed are cleaned up.
382  */
383 
384  virtual void reset() = 0;
385 
386  /**
387  Has the same behavior as the reset but additionaly flushes buffered
388  messages.
389  */
390 
391  virtual void reset_with_flush() = 0;
392 
393  /**
394  If messages were buffered during its processing, they are delivered
395  to upper layers and internal structures needed are cleaned up.
396  */
397 
398  virtual void end() = 0;
399 
400  /**
401  Signals the module to start a State Exchange.
402 
403  @param[in] configuration_id Configuration identifier in use when the state
404  exchange phase started
405  @param[in] total xcom total members in the new view
406  @param[in] left xcom members that left in the new view
407  @param[in] joined xcom members that joined in the new view
408  @param[in] exchangeable_data generic exchanged data
409  @param[in] current_view the currently installed view
410  @param[in] group group name
411  @param[in] local_info the local GCS member identifier
412  @param[in] xcom_nodes list of nodes
413 
414  @return true if the member is leaving
415  */
416 
417  virtual bool state_exchange(
418  synode_no configuration_id, std::vector<Gcs_member_identifier *> &total,
419  std::vector<Gcs_member_identifier *> &left,
420  std::vector<Gcs_member_identifier *> &joined,
421  std::vector<std::unique_ptr<Gcs_message_data>> &exchangeable_data,
422  Gcs_view *current_view, std::string *group,
423  const Gcs_member_identifier &local_info,
424  const Gcs_xcom_nodes &xcom_nodes) = 0;
425 
426  /**
427  Processes a member state message on an ongoing State Exchange round.
428 
429  @param[in] ms_info received Member State
430  @param[in] p_id the node that the Member State pertains
431  @param[in] maximum_supported_protocol_version maximum supported protocol
432  version
433  @param[in] used_protocol_version protocol version in use by a member during
434  the state exchange phase
435 
436  @return true if State Exchanged is to be finished and the view can be
437  installed
438  */
439 
440  virtual bool process_member_state(
441  Xcom_member_state *ms_info, const Gcs_member_identifier &p_id,
442  Gcs_protocol_version maximum_supported_protocol_version,
443  Gcs_protocol_version used_protocol_version) = 0;
444 
445  /**
446  Compute the set of incompatible members after the state exchange has
447  finished.
448  A member M is incompatible if it is attempting to join a group that is
449  using protocol X, but M is using protocol Y s.t. X != Y.
450  @returns the set of incompatible members
451  */
452  virtual std::vector<Gcs_xcom_node_information>
453  compute_incompatible_members() = 0;
454 
455  /**
456  Recovers any missing packets required for the member to join the group.
457  @retval true if successful
458  @retval false otherwise
459  */
460  virtual bool process_recovery_state() = 0;
461 
462  /**
463  Retrieves the new view identifier after a State Exchange.
464 
465  @return the new view identifier
466  */
467 
468  virtual Gcs_xcom_view_identifier *get_new_view_id() = 0;
469 
470  /**
471  @return the members that joined in this State Exchange round
472  */
473 
474  virtual std::set<Gcs_member_identifier *> *get_joined() = 0;
475 
476  /**
477  @return the members that left in this State Exchange round
478  */
479 
480  virtual std::set<Gcs_member_identifier *> *get_left() = 0;
481 
482  /**
483  @return All the members in this State Exchange round
484  */
485 
486  virtual std::set<Gcs_member_identifier *> *get_total() = 0;
487 
488  /**
489  @return the group in which this State Exchange is occurring
490  */
491 
492  virtual std::string *get_group() = 0;
493 
494  /**
495  @return the saved states
496  */
497 
498  virtual std::map<Gcs_member_identifier, Xcom_member_state *>
499  *get_member_states() = 0;
500 
501  /**
502  Computes the maximum protocol version supported by the group.
503  */
504  virtual void compute_maximum_supported_protocol_version() = 0;
505 };
506 
507 /**
508  Implementation of the gcs_xcom_state_exchange_interface.
509 */
511  public:
512  /**
513  State Exchange constructor.
514 
515  @param[in] comm Communication interface reference to allow broadcasting of
516  member states
517  */
518 
520 
521  ~Gcs_xcom_state_exchange() override;
522 
523  // Implementation of gcs_xcom_state_exchange_interface
524  void init() override;
525 
526  void reset() override;
527 
528  void reset_with_flush() override;
529 
530  void end() override;
531 
532  bool state_exchange(
533  synode_no configuration_id, std::vector<Gcs_member_identifier *> &total,
534  std::vector<Gcs_member_identifier *> &left,
535  std::vector<Gcs_member_identifier *> &joined,
536  std::vector<std::unique_ptr<Gcs_message_data>> &exchangeable_data,
537  Gcs_view *current_view, std::string *group,
538  const Gcs_member_identifier &local_info,
539  const Gcs_xcom_nodes &xcom_nodes) override;
540 
541  bool process_member_state(
542  Xcom_member_state *ms_info, const Gcs_member_identifier &p_id,
543  Gcs_protocol_version maximum_supported_protocol_version,
544  Gcs_protocol_version used_protocol_version) override;
545 
546  std::vector<Gcs_xcom_node_information> compute_incompatible_members()
547  override;
548 
549  bool process_recovery_state() override;
550 
551  Gcs_xcom_view_identifier *get_new_view_id() override;
552 
553  std::set<Gcs_member_identifier *> *get_joined() override {
554  return &m_ms_joined;
555  }
556 
557  std::set<Gcs_member_identifier *> *get_left() override { return &m_ms_left; }
558 
559  std::set<Gcs_member_identifier *> *get_total() override {
560  return &m_ms_total;
561  }
562 
563  std::map<Gcs_member_identifier, Xcom_member_state *> *get_member_states()
564  override {
565  return &m_member_states;
566  }
567 
568  std::string *get_group() override { return m_group_name; }
569 
570  void compute_maximum_supported_protocol_version() override;
571 
572  private:
573  /**
574  Computes if the local member is leaving.
575 
576  @return true in case of the local member is leaving
577  */
578 
579  bool is_leaving();
580 
581  /**
582  Computes if the local member is joining.
583 
584  @return true in case of the local member is joining
585  */
586 
587  bool is_joining();
588 
589  /**
590  Update the communication system with information on membership.
591 
592  @param xcom_nodes List of nodes that belong to the current membership.
593  */
594  void update_communication_channel(const Gcs_xcom_nodes &xcom_nodes);
595 
596  /**
597  Broadcasts the local state to all nodes in the Cluster.
598 
599  @param[in] proposed_view proposed view to broadcast
600  @param[in] exchangeable_data List with exchangeable messages
601  */
602 
603  enum_gcs_error broadcast_state(
604  const Gcs_xcom_view_identifier &proposed_view,
605  std::vector<std::unique_ptr<Gcs_message_data>> &exchangeable_data);
606 
607  /**
608  Updates the structure that waits for State Exchanges.
609  */
610 
611  void update_awaited_vector();
612 
613  /**
614  Converts xcom data to a set of internal representation.
615 
616  @param[in] in xcom list
617  @param[in] pset Set where the converted member ids will be written
618  */
619 
620  void fill_member_set(std::vector<Gcs_member_identifier *> &in,
621  std::set<Gcs_member_identifier *> &pset);
622 
623  /**
624  Stores the member's state and protocol version.
625 
626  @param ms_info state
627  @param p_id member
628  @param[in] maximum_supported_protocol_version maximum supported protocol
629  version
630  @param used_protocol_version protocol version
631  */
632  void save_member_state(
633  Xcom_member_state *ms_info, const Gcs_member_identifier &p_id,
634  Gcs_protocol_version maximum_supported_protocol_version,
635  Gcs_protocol_version used_protocol_version);
636 
637  /**
638  Auxiliary method that checks whether @c snapshot_to_recover contains all
639  the synodes required.
640  */
641  bool snapshot_is_enough(Gcs_xcom_synode_set const &snapshot_to_recover) const;
642 
643  /**
644  Checks whether all the existing group members, myself excluded, announce the
645  same protocol version.
646  @retval {false, _} if they do not all announce the same protocol version
647  @retval {true, Gcs_protocol_version} if they all announced the same protocol
648  version of the return value
649  */
650  std::pair<bool, Gcs_protocol_version> members_announce_same_version() const;
651 
652  /**
653  Checks whether this server is incompatible with the group.
654  @retval true If it is incompatible
655  @retval false If it is compatible
656  */
657  bool incompatible_with_group() const;
658 
659  /**
660  Computes the set of incompatible nodes that are trying to join the group.
661  @returns the set of incompatible joiners
662  */
663  std::vector<Gcs_xcom_node_information> compute_incompatible_joiners();
664 
666 
667  std::map<Gcs_member_identifier, uint> m_awaited_vector;
668 
669  std::map<Gcs_member_identifier, uint> m_recover_vector;
670 
671  /* Set of ids in GCS native format as reported by View-change handler. */
672  std::set<Gcs_member_identifier *> m_ms_total, m_ms_left, m_ms_joined;
673 
674  /* Collection of State Message contents to facilitate view installation. */
675  std::map<Gcs_member_identifier, Xcom_member_state *> m_member_states;
676 
677  /* Collection of protocol version in use per member. */
678  std::map<Gcs_member_identifier, Gcs_protocol_version> m_member_versions;
679 
680  /* Collection of maximum protocol version supported per member. */
681  std::map<Gcs_member_identifier, Gcs_protocol_version> m_member_max_versions;
682 
683  // Group name to exchange state
684  std::string *m_group_name;
685 
686  // Local GCS member identification
688 
689  /* Configuration identifier in use when the state exchange phase started */
691 
692  std::vector<synode_no> cached_ids;
693 
694  /* XCom identifiers of the members in m_ms_total */
696 
697  /*
698  Disabling the copy constructor and assignment operator.
699  */
702 };
703 
704 /*
705  @interface gcs_xcom_view_change_control_interface
706 
707  This interface will serve as a synchronization point to all those that are
708  interested in maintaining view safety. This will guarantee that no actions are
709  accomplished while a view change procedure is ongoing.
710 
711  The promoters of view change will indicate via start_view_exchange() and
712  end_view_exchange() the boundaries of the process. Those that want to wait
713  for the end, will synchronize on wait_for_view_change_end().
714 */
716  public:
718 
719  virtual void start_view_exchange() = 0;
720  virtual void end_view_exchange() = 0;
721  virtual void wait_for_view_change_end() = 0;
722  virtual bool is_view_changing() = 0;
723 
724  // Leave related information
725  virtual bool start_leave() = 0;
726  virtual void end_leave() = 0;
727  virtual bool is_leaving() = 0;
728 
729  // Join related information
730  virtual bool start_join() = 0;
731  virtual void end_join() = 0;
732  virtual bool is_joining() = 0;
733 
734  // Keep track of delivered views
735  virtual void set_current_view(Gcs_view *current_view) = 0;
736  virtual Gcs_view *get_current_view() = 0;
737  virtual bool belongs_to_group() = 0;
738  virtual void set_belongs_to_group(bool belong) = 0;
739  virtual void set_unsafe_current_view(Gcs_view *current_view) = 0;
740  virtual Gcs_view *get_unsafe_current_view() = 0;
741 };
742 
743 /*
744  @class gcs_xcom_view_change_control
745 
746  Implementation of gcs_xcom_view_change_control_interface.
747 */
750  public:
751  explicit Gcs_xcom_view_change_control();
752  ~Gcs_xcom_view_change_control() override;
753 
754  void start_view_exchange() override;
755  void end_view_exchange() override;
756  void wait_for_view_change_end() override;
757  bool is_view_changing() override;
758 
759  bool start_leave() override;
760  void end_leave() override;
761  bool is_leaving() override;
762 
763  bool start_join() override;
764  void end_join() override;
765  bool is_joining() override;
766 
767  void set_current_view(Gcs_view *current_view) override;
768  Gcs_view *get_current_view() override;
769  bool belongs_to_group() override;
770  void set_belongs_to_group(bool belong) override;
771  void set_unsafe_current_view(Gcs_view *current_view) override;
772  Gcs_view *get_unsafe_current_view() override;
773 
774  private:
776  bool m_leaving;
777  bool m_joining;
778 
782 
783  /*
784  Reference to the currently installed view.
785  */
787 
788  /*
789  Protect access to the current view so that it can be
790  copied and returned.
791  */
793 
794  /*
795  Whether the current node belongs to a group or not.
796  */
798 
799  /*
800  Disabling the copy constructor and assignment operator.
801  */
804 };
805 #endif /* GCS_XCOM_STATE_EXCHANGE_INCLUDED */
std::map< Gcs_member_identifier, Xcom_member_state * > * get_member_states() override
Definition: gcs_xcom_state_exchange.h:563
unsigned char uchar
Definition: my_inttypes.h:51
std::set< Gcs_member_identifier * > * get_left() override
Definition: gcs_xcom_state_exchange.h:557
std::map< Gcs_member_identifier, Gcs_protocol_version > m_member_max_versions
Definition: gcs_xcom_state_exchange.h:681
virtual ~Gcs_xcom_state_exchange_interface()
Definition: gcs_xcom_state_exchange.h:371
uint64_t get_encode_snapshot_size() const
Definition: gcs_xcom_state_exchange.cc:77
Definition: gcs_xcom_state_exchange.h:748
std::set< Gcs_member_identifier * > m_ms_total
Definition: gcs_xcom_state_exchange.h:672
std::map< Gcs_member_identifier, uint > m_awaited_vector
Definition: gcs_xcom_state_exchange.h:667
char buffer[STRING_BUFFER]
Definition: test_sql_9_sessions.cc:57
std::vector< T, ut_allocator< T > > vector
Specialization of vector which uses ut_allocator.
Definition: ut0new.h:1306
std::string * get_group() override
Definition: gcs_xcom_state_exchange.h:568
static constexpr auto WIRE_XCOM_NODE_ID_SIZE
Definition: gcs_xcom_state_exchange.h:251
static constexpr auto WIRE_XCOM_SNAPSHOT_NR_ELEMS_SIZE
Definition: gcs_xcom_state_exchange.h:252
Gcs_xcom_synode_set m_snapshot
Recovery information which is currently a list of the XCom synods of the fragments that are in buffer...
Definition: gcs_xcom_state_exchange.h:288
std::map< Gcs_member_identifier, uint > m_recover_vector
Definition: gcs_xcom_state_exchange.h:669
~Xcom_member_state()
Member state destructor.
Definition: gcs_xcom_state_exchange.cc:68
Definition: my_xp_cond.h:133
static constexpr auto WIRE_XCOM_GROUP_ID_SIZE
Definition: gcs_xcom_state_exchange.h:249
static constexpr uint64_t get_encode_header_size()
Definition: gcs_xcom_state_exchange.h:208
std::set< Gcs_member_identifier * > * get_total() override
Definition: gcs_xcom_state_exchange.h:559
enum_gcs_error
This enumeration describes errors which can occur during group communication operations.
Definition: gcs_types.h:40
std::unordered_set< Gcs_xcom_synode > Gcs_xcom_synode_set
Definition: gcs_xcom_synode.h:83
Gcs_protocol_version
The GCS protocol versions.
Definition: gcs_types.h:127
synode_no m_configuration_id
Definition: gcs_xcom_state_exchange.h:690
Gcs_communication_interface * m_broadcaster
Definition: gcs_xcom_state_exchange.h:665
static constexpr auto WIRE_XCOM_VARIABLE_VIEW_ID_SIZE
Definition: gcs_xcom_state_exchange.h:247
bool decode_snapshot(const uchar *buffer, uint64_t buffer_len)
Decodes the Member State&#39;s snapshot that was sent through the network.
Definition: gcs_xcom_state_exchange.cc:234
bool decode(const uchar *data, uint64_t data_size)
Decodes Member State that was sent through the network.
Definition: gcs_xcom_state_exchange.cc:276
std::map< Gcs_member_identifier, Xcom_member_state * > m_member_states
Definition: gcs_xcom_state_exchange.h:675
static mysql_service_status_t init()
Component initialization.
Definition: audit_api_message_emit.cc:570
Gcs_xcom_view_identifier * get_view_id()
Definition: gcs_xcom_state_exchange.h:224
std::string * m_group_name
Definition: gcs_xcom_state_exchange.h:684
const uchar * get_data() const
Definition: gcs_xcom_state_exchange.h:236
Gcs_protocol_version m_version
GCS communication version number in use.
Definition: gcs_xcom_state_exchange.h:293
uchar * m_data
Definition: gcs_xcom_state_exchange.h:273
static constexpr uint64_t get_encode_snapshot_elem_size()
Definition: gcs_xcom_state_exchange.h:254
bool decode_header(const uchar *buffer, uint64_t buffer_len)
Decodes the Member State&#39;s header that was sent through the network.
Definition: gcs_xcom_state_exchange.cc:201
const Gcs_xcom_synode_set & get_snapshot() const
Definition: gcs_xcom_state_exchange.h:244
Type total(const Shards< COUNT > &shards) noexcept
Get the total value of all shards.
Definition: ut0counter.h:332
Xcom_member_state & operator=(Xcom_member_state const &)=delete
Xcom_member_state(const Gcs_xcom_view_identifier &view_id, synode_no configuration_id, Gcs_protocol_version version, const Gcs_xcom_synode_set &snapshot, const uchar *data, uint64_t data_size)
Xcom_member_state constructor.
Definition: gcs_xcom_state_exchange.cc:37
std::map< Gcs_member_identifier, Gcs_protocol_version > m_member_versions
Definition: gcs_xcom_state_exchange.h:678
Cursor end()
A past-the-end Cursor.
Definition: rules_table_service.cc:188
bool m_joining
Definition: gcs_xcom_state_exchange.h:777
This interface represents all the communication facilities that a binding implementation should provi...
Definition: gcs_communication_interface.h:87
uint64_t get_encode_payload_size() const
Definition: gcs_xcom_state_exchange.cc:73
Gcs_xcom_view_identifier * m_view_id
Definition: gcs_xcom_state_exchange.h:262
It represents the identity of a group member within a certain group.
Definition: gcs_member_identifier.h:39
This represents the membership view that a member has from a group.
Definition: gcs_view.h:54
My_xp_mutex_impl m_current_view_mutex
Definition: gcs_xcom_state_exchange.h:792
bool m_leaving
Definition: gcs_xcom_state_exchange.h:776
static constexpr auto WIRE_XCOM_MSG_ID_SIZE
Definition: gcs_xcom_state_exchange.h:250
const string version("\ersion\)
Class that conveys the state to be exchanged between members, which is not provided by XCom...
Definition: gcs_xcom_state_exchange.h:104
This class contains information on the configuration, i.e set of nodes or simply site definition...
Definition: gcs_xcom_group_member_information.h:390
std::string HARNESS_EXPORT reset()
get &#39;reset attributes&#39; ESC sequence.
Definition: vt100.cc:36
bool m_view_changing
Definition: gcs_xcom_state_exchange.h:775
uint64_t get_data_size() const
Definition: gcs_xcom_state_exchange.h:242
Implementation of the gcs_xcom_state_exchange_interface.
Definition: gcs_xcom_state_exchange.h:510
uint64_t m_data_size
Definition: gcs_xcom_state_exchange.h:278
My_xp_mutex_impl m_wait_for_view_mutex
Definition: gcs_xcom_state_exchange.h:780
bool encode_header(uchar *buffer, uint64_t *buffer_len) const
Encodes the Member State&#39;s header to be sent through the newtwork.
Definition: gcs_xcom_state_exchange.cc:90
synode_no m_configuration_id
Definition: gcs_xcom_state_exchange.h:268
Gcs_member_identifier m_local_information
Definition: gcs_xcom_state_exchange.h:687
bool m_belongs_to_group
Definition: gcs_xcom_state_exchange.h:797
std::set< Gcs_member_identifier * > * get_joined() override
Definition: gcs_xcom_state_exchange.h:553
synode_no get_configuration_id() const
Definition: gcs_xcom_state_exchange.h:230
Gcs_xcom_nodes m_ms_xcom_nodes
Definition: gcs_xcom_state_exchange.h:695
virtual ~Gcs_xcom_view_change_control_interface()
Definition: gcs_xcom_state_exchange.h:717
Definition: gcs_xcom_state_exchange.h:715
Definition: my_xp_mutex.h:120
bool encode_snapshot(uchar *buffer, uint64_t *buffer_len) const
Encodes the Member State&#39;s snapshot to be sent through the network.
Definition: gcs_xcom_state_exchange.cc:155
Definition: gcs_xcom_state_exchange.h:369
static constexpr auto WIRE_XCOM_VIEW_ID_SIZE
Definition: gcs_xcom_state_exchange.h:248
Definition: gcs_xcom_view_identifier.h:32
std::vector< synode_no > cached_ids
Definition: gcs_xcom_state_exchange.h:692
Gcs_view * m_current_view
Definition: gcs_xcom_state_exchange.h:786
My_xp_mutex_impl m_joining_leaving_mutex
Definition: gcs_xcom_state_exchange.h:781
My_xp_cond_impl m_wait_for_view_cond
Definition: gcs_xcom_state_exchange.h:779