Bug#25876807: FOR DIFFERENT VERSION (5.7 AND 8.0) GROUP, LEADER SHOULD BE

              ONLY FROM LOWER VERSION

PROBLEM STATEMENT
=================
When a group contain members of two different versions (5.7 & 8.0), higher
version members are put in read compatability mode and cannot write to the
group. In single primary-mode, currently the primary member can be elected
from the higher version members also thus making a member what should be in
read mode writable, what can lead to failures in the lower version members.

PROPOSED SOLUTIONS
==================
The primary member should be elected from lower version members i.e 5.7, in
single primary-mode. And so only the members with the lowest versions should
participate in the election.

Author: Hemant Dangi

rapid/plugin/group_replication/include/gcs_event_handlers.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -40,7 +40,7 @@ struct Group_member_info_pointer_comparator
   bool operator()(Group_member_info* one,
                   Group_member_info* other) const
   {
-    return *one < *other;
+    return other->has_greater_uuid(one);
   }
 };
 
@@ -132,6 +132,32 @@ class Plugin_gcs_events_handler: public Gcs_communication_event_listener,
   */
   void handle_leader_election_if_needed() const;
 
+  /**
+    Sort lower version members based on uuid
+
+    @param all_members_info   the vector with members info
+
+    @return first iterator position where members version increase.
+   */
+  void sort_members_for_election(
+       std::vector<Group_member_info*>* all_members_info,
+       std::vector<Group_member_info*>::iterator lowest_version_end) const;
+
+  /**
+    Sort members based on member_version and get first iterator position
+    where member version differs.
+
+    @param all_members_info    the vector with members info
+    @param lowest_version_end  first iterator position where members version
+                               increases.
+
+    @note from the start of the list to the returned iterator, all members have
+          the lowest version in the group.
+   */
+  std::vector<Group_member_info*>::iterator
+  sort_and_get_lowest_version_member_position(
+    std::vector<Group_member_info*>* all_members_info) const;
+
   int
   process_local_exchanged_data(const Exchanged_data &exchanged_data) const;
 

rapid/plugin/group_replication/include/member_info.h

@@ -291,9 +291,29 @@ class Group_member_info: public Plugin_gcs_message
   static std::string get_configuration_flags_string(const uint32 configuation_flags);
 
   /**
-    @return Compare two members using "operator <"
+    @return Compare two members using member version
    */
-  static bool comparator_group_member_info(Group_member_info *m1, Group_member_info *m2);
+  static bool comparator_group_member_version(Group_member_info *m1, Group_member_info *m2);
+
+  /**
+    @return Compare two members using server uuid
+   */
+  static bool comparator_group_member_uuid(Group_member_info *m1, Group_member_info *m2);
+
+  /**
+    Return true if member version is higher than other member version
+   */
+  bool has_greater_version(Group_member_info *other);
+
+  /**
+    Return true if server uuid is higher than other member server uuid
+   */
+  bool has_greater_uuid(Group_member_info *other);
+
+  /**
+    Return true if server uuid is equal than other member server uuid
+   */
+  bool has_equal_uuid(Group_member_info *other);
 
   /**
    Redefinition of operate == and <. They operate upon the uuid

rapid/plugin/group_replication/src/gcs_event_handlers.cc

@@ -400,6 +400,55 @@ Plugin_gcs_events_handler::was_member_expelled_from_group(const Gcs_view& view)
   DBUG_RETURN(result);
 }
 
+std::vector<Group_member_info*>::iterator
+Plugin_gcs_events_handler::sort_and_get_lowest_version_member_position(
+  std::vector<Group_member_info*>* all_members_info) const
+{
+  std::vector<Group_member_info*>::iterator it;
+
+  // sort in ascending order of lower member version
+  std::sort(all_members_info->begin(), all_members_info->end(),
+            Group_member_info::comparator_group_member_version);
+
+  /* if vector contains only single version then leader should be picked from
+     all members
+   */
+  std::vector<Group_member_info*>::iterator lowest_version_end=
+    all_members_info->end();
+
+  /* first member will have lowest version as members are already
+     sorted above using member_version.
+   */
+  it= all_members_info->begin();
+  Group_member_info* first_member= *it;
+  uint32 lowest_major_version=
+    first_member->get_member_version().get_major_version();
+
+  /* to avoid read compatibility issue leader should be picked only from lowest
+     version members so save position where member version differs
+   */
+  for(it= all_members_info->begin() + 1; it != all_members_info->end(); it++)
+  {
+    if (lowest_major_version != (*it)->get_member_version().get_major_version())
+    {
+      lowest_version_end= it;
+      break;
+    }
+  }
+
+  return lowest_version_end;
+}
+
+void Plugin_gcs_events_handler::sort_members_for_election(
+       std::vector<Group_member_info*>* all_members_info,
+       std::vector<Group_member_info*>::iterator lowest_version_end) const
+{
+  // sort only lower version members as they only will be needed to pick leader
+  std::sort(all_members_info->begin(), lowest_version_end,
+            Group_member_info::comparator_group_member_uuid);
+
+}
+
 void Plugin_gcs_events_handler::handle_leader_election_if_needed() const
 {
   // take action if in single leader mode
@@ -415,8 +464,16 @@ void Plugin_gcs_events_handler::handle_leader_election_if_needed() const
     group_member_mgr->get_all_members();
 
   std::vector<Group_member_info*>::iterator it;
-  std::sort(all_members_info->begin(), all_members_info->end(),
-            Group_member_info::comparator_group_member_info);
+  std::vector<Group_member_info*>::iterator lowest_version_end;
+
+  /* sort members based on member_version and get first iterator position
+     where member version differs
+   */
+  lowest_version_end=
+    sort_and_get_lowest_version_member_position(all_members_info);
+
+  // sort lower version members based on uuid
+  sort_members_for_election(all_members_info, lowest_version_end);
 
   /*
    1. Iterate over the list of all members and check if there is a primary
@@ -476,11 +533,14 @@ void Plugin_gcs_events_handler::handle_leader_election_if_needed() const
 
      The assumption is that std::sort(...) is deterministic
      on all members.
+
+     To pick leaders from only lowest version members loop
+     till lowest_version_end.
     */
     if (the_primary == NULL)
     {
       for (it= all_members_info->begin();
-           it != all_members_info->end() && the_primary == NULL;
+           it != lowest_version_end && the_primary == NULL;
            it++)
       {
         Group_member_info* mi= *it;

rapid/plugin/group_replication/src/member_info.cc

@@ -392,12 +392,6 @@ bool Group_member_info::is_conflict_detection_enabled()
   return conflict_detection_enable;
 }
 
-bool
-Group_member_info::operator <(Group_member_info& other)
-{
-  return this->get_uuid().compare(other.get_uuid()) < 0;
-}
-
 bool
 Group_member_info::operator ==(Group_member_info& other)
 {
@@ -466,12 +460,34 @@ Group_member_info::get_configuration_flags_string(const uint32 configuation_flag
 }
 
 bool
-Group_member_info::comparator_group_member_info(Group_member_info *m1,
+Group_member_info::comparator_group_member_version(Group_member_info *m1,
+                                                   Group_member_info *m2)
+{
+  return m2->has_greater_version(m1);
+}
+
+bool
+Group_member_info::comparator_group_member_uuid(Group_member_info *m1,
                                                 Group_member_info *m2)
 {
-  return *m1 < *m2;
+  return m2->has_greater_uuid(m1);
 }
 
+bool
+Group_member_info::has_greater_version(Group_member_info *other)
+{
+  if (this->member_version->get_major_version() >
+        other->member_version->get_major_version())
+    return true;
+
+  return false;
+}
+
+bool
+Group_member_info::has_greater_uuid(Group_member_info *other)
+{
+  return this->get_uuid().compare(other->get_uuid()) < 0;
+}
 
 Group_member_info_manager::
 Group_member_info_manager(Group_member_info* local_member_info)