Bug#35605595 MySQL shell needs to support GTID tags

Starting in 8.3.0, the server supports GTID with tags. Essentially,
after the UUID component of the GTID and before the range, there might
now be a tag to associate with the GTID. This means that a GTID is now
uniquely identified with UUID+tag (empty tags are valid and represent
the previous, non-tagged GTIDs).

The AdminAPI needs to call several server APIS (i.e: gtid_subtract()) in
order to process and compare GTIDs from different servers, like for
example when joining an instances to a Cluster. But since the primary
and the new instance can have different version, this means that the
new instance (running 8.3.0) can have tagged GTIDs, which the primary
(running a version less than 8.3.0) doesn't know how to process. In this
case, the primary throws an error (malformed GTID), which will abort,
for example, a cluster.addInstance() request.

This patch takes this scenario into account by checking the server
version and if the GTIDs of a joining member are tagged. If the server
doesn't support tagged GTIDs and they are present, then the current
command is aborted and the user informed that, in order to use tagged
GTIDs, all members of a Cluster or ReplicaSet must be at version 8.3.0
or newer.

Change-Id: I47e0db9c355cd815ad6b389e6e280e30d07353c1

Author: joaosigma

modules/adminapi/cluster_set/cluster_set_impl.cc

@@ -3021,50 +3021,54 @@ void Cluster_set_impl::ensure_transaction_set_consistent_and_recoverable(
     bool *out_is_recoverable) {
   mysqlshdk::mysql::Gtid_set missing_view_gtids;
   mysqlshdk::mysql::Gtid_set errant_gtids;
-  mysqlshdk::mysql::Gtid_set missing_gtids;
   mysqlshdk::mysql::Gtid_set unrecoverable_gtids;
 
-  std::vector<std::string> allowed_errant_uuids;
-  std::vector<Cluster_set_member_metadata> members;
+  {
+    // purged GTIDs from all members of the primary
+    std::vector<mysqlshdk::mysql::Gtid_set> purged_gtids;
 
-  // purged GTIDs from all members of the primary
-  std::vector<mysqlshdk::mysql::Gtid_set> purged_gtids;
+    primary_cluster->execute_in_members(
+        [&purged_gtids](const std::shared_ptr<Instance> &instance,
+                        const Cluster_impl::Instance_md_and_gr_member &) {
+          auto purged = mysqlshdk::mysql::Gtid_set::from_gtid_purged(*instance);
 
-  primary_cluster->execute_in_members(
-      [&purged_gtids](const std::shared_ptr<Instance> &instance,
-                      const Cluster_impl::Instance_md_and_gr_member &) {
-        auto purged = mysqlshdk::mysql::Gtid_set::from_gtid_purged(*instance);
+          log_debug("gtid_purged@%s=%s", instance->descr().c_str(),
+                    purged.str().c_str());
+          purged_gtids.emplace_back(purged);
+          return true;
+        },
+        [](const shcore::Error &err,
+           const Cluster_impl::Instance_md_and_gr_member &i) {
+          log_debug("could not connect to %s:%i to query gtid_purged: %s",
+                    i.second.host.c_str(), i.second.port, err.format().c_str());
+          return true;
+        });
 
-        log_debug("gtid_purged@%s=%s", instance->descr().c_str(),
-                  purged.str().c_str());
-        purged_gtids.emplace_back(purged);
-        return true;
-      },
-      [](const shcore::Error &err,
-         const Cluster_impl::Instance_md_and_gr_member &i) {
-        log_debug("could not connect to %s:%i to query gtid_purged: %s",
-                  i.second.host.c_str(), i.second.port, err.format().c_str());
-        return true;
-      });
+    std::vector<Cluster_set_member_metadata> members;
+    get_metadata_storage()->get_cluster_set(get_id(), true, nullptr, &members);
 
-  get_metadata_storage()->get_cluster_set(get_id(), true, nullptr, &members);
-  for (const auto &m : members) {
-    allowed_errant_uuids.push_back(m.cluster.view_change_uuid);
-  }
+    std::vector<std::string> allowed_errant_uuids;
+    allowed_errant_uuids.reserve(members.size());
+    for (const auto &m : members) {
+      allowed_errant_uuids.push_back(m.cluster.view_change_uuid);
+    }
 
-  mysqlshdk::mysql::compute_joining_replica_gtid_state(
-      *primary, mysqlshdk::mysql::Gtid_set::from_gtid_executed(*primary),
-      purged_gtids, mysqlshdk::mysql::Gtid_set::from_gtid_executed(*replica),
-      allowed_errant_uuids, &missing_gtids, &unrecoverable_gtids, &errant_gtids,
-      &missing_view_gtids);
+    mysqlshdk::mysql::Gtid_set missing_gtids;
 
-  log_info(
-      "GTID check between %s and %s (%s) missing=%s errant=%s unrecoverable=%s "
-      "vcle=%s\n",
-      replica->descr().c_str(), primary_cluster->get_name().c_str(),
-      primary->descr().c_str(), missing_gtids.str().c_str(),
-      errant_gtids.str().c_str(), unrecoverable_gtids.str().c_str(),
-      missing_view_gtids.str().c_str());
+    mysqlshdk::mysql::compute_joining_replica_gtid_state(
+        *primary, mysqlshdk::mysql::Gtid_set::from_gtid_executed(*primary),
+        purged_gtids, mysqlshdk::mysql::Gtid_set::from_gtid_executed(*replica),
+        allowed_errant_uuids, &missing_gtids, &unrecoverable_gtids,
+        &errant_gtids, &missing_view_gtids);
+
+    log_info(
+        "GTID check between '%s' and '%s' ('%s'): missing='%s' errant='%s' "
+        "unrecoverable='%s' vcle='%s'",
+        replica->descr().c_str(), primary_cluster->get_name().c_str(),
+        primary->descr().c_str(), missing_gtids.str().c_str(),
+        errant_gtids.str().c_str(), unrecoverable_gtids.str().c_str(),
+        missing_view_gtids.str().c_str());
+  }
 
   if (out_is_recoverable) *out_is_recoverable = true;
 

modules/adminapi/common/common.cc

@@ -1724,8 +1724,6 @@ std::vector<Instance_gtid_info> filter_primary_candidates(
     const std::vector<Instance_gtid_info> &gtid_info,
     const std::function<bool(const Instance_gtid_info &,
                              const Instance_gtid_info &)> &on_conflit) {
-  using mysqlshdk::mysql::Gtid_set_relation;
-
   if (gtid_info.empty()) return {};
 
   std::vector<Instance_gtid_info> candidates;
@@ -1740,14 +1738,17 @@ std::vector<Instance_gtid_info> filter_primary_candidates(
         server, freshest_instance->gtid_executed, inst.gtid_executed);
 
     switch (rel) {
+      using mysqlshdk::mysql::Gtid_set_relation;
+
       // Conflicting GTID sets
       case Gtid_set_relation::DISJOINT:
       case Gtid_set_relation::INTERSECTS:
         if (!on_conflit)
-          throw shcore::Exception("Conflicting transaction sets between " +
-                                      freshest_instance->server + " and " +
-                                      inst.server,
-                                  SHERR_DBA_DATA_ERRANT_TRANSACTIONS);
+          throw shcore::Exception(
+              shcore::str_format(
+                  "Conflicting transaction sets between '%s' and '%s'",
+                  freshest_instance->server.c_str(), inst.server.c_str()),
+              SHERR_DBA_DATA_ERRANT_TRANSACTIONS);
 
         if (!on_conflit(*freshest_instance, inst)) return candidates;
         break;
@@ -1919,7 +1920,7 @@ bool wait_for_gtid_set_safe(const mysqlshdk::mysql::IInstance &target_instance,
         mysqlshdk::mysql::Gtid_set::from_gtid_executed(target_instance);
 
     return mysqlshdk::mysql::estimate_gtid_set_size(
-        gtid_set_primary.subtract(gtid_set_target, target_instance));
+        gtid_set_primary.subtract(gtid_set_target, target_instance).str());
   };
 
   using Progress_reporting = Shell_options::Storage::Progress_reporting;