CDRIVER-424 Fix node selection with read preference tags

Author: TylerBrock

src/mongoc/mongoc-cluster.c

@@ -743,14 +743,22 @@ _mongoc_cluster_select (mongoc_cluster_t             *cluster,
 
    count = 0;
 
+   int scores[MONGOC_CLUSTER_MAX_NODES];
+   int max_score = 0;
+
    for (i = 0; i < MONGOC_CLUSTER_MAX_NODES; i++) {
       if (nodes[i]) {
          if (read_prefs) {
             int score = _mongoc_read_prefs_score(read_prefs, nodes[i]);
+            scores[i] = score;
+
             if (score < 0) {
                nodes[i] = NULL;
                continue;
+            } else if (score > max_score) {
+                max_score = score;
             }
+
          }
          if (IS_NEARER_THAN(nodes[i], nearest)) {
             nearest = nodes[i]->ping_avg_msec;
@@ -776,6 +784,19 @@ _mongoc_cluster_select (mongoc_cluster_t             *cluster,
       }
    }
 
+   /*
+    * Filter nodes with score less than highest score.
+    */
+   if (max_score) {
+      for (i = 0; i < MONGOC_CLUSTER_MAX_NODES; i++) {
+         if (nodes[i] && scores[i] < max_score) {
+             nodes[i] = NULL;
+             count--;
+         }
+      }
+   }
+
+
    /*
     * Mark the error as unable to locate a target node.
     */
@@ -1091,6 +1112,18 @@ _mongoc_cluster_ismaster (mongoc_cluster_t      *cluster,
           BSON_ITER_HOLDS_UTF8(&iter)) {
          node->replSet = bson_iter_dup_utf8(&iter, NULL);
       }
+      if (bson_iter_init_find(&iter, &reply, "tags") &&
+          BSON_ITER_HOLDS_DOCUMENT(&iter)) {
+          bson_t tags;
+          uint32_t len;
+          const uint8_t *data;
+
+          bson_iter_document(&iter, &len, &data);
+
+          if (bson_init_static(&tags, data, len)) {
+              bson_copy_to(&tags, &(node->tags));
+          }
+      }
    }
 
    ret = true;

src/mongoc/mongoc-read-prefs.c

@@ -144,24 +144,46 @@ _score_tags (const bson_t *read_tags,
 {
    uint32_t len;
    bson_iter_t iter;
+   bson_iter_t sub_iter;
    const char *key;
    const char *str;
    int count;
-   int i;
+   bool node_matches_set;
 
    bson_return_val_if_fail(read_tags, -1);
    bson_return_val_if_fail(node_tags, -1);
 
    count = bson_count_keys(read_tags);
 
+   // Execute this block if read tags were provided, else bail and return 0 (all nodes equal)
    if (!bson_empty(read_tags) && bson_iter_init(&iter, read_tags)) {
-      for (i = count; bson_iter_next(&iter); i--) {
-         if (BSON_ITER_HOLDS_UTF8(&iter)) {
-            key = bson_iter_key(&iter);
-            str = bson_iter_utf8(&iter, &len);
-            if (_contains_tag(node_tags, key, str, len)) {
-               return count;
+
+      // Iterate over array of read tag sets provided (each element is a tag set)
+      // Tag sets are provided in order of preference so return the count of the
+      // first set that matches the node or -1 if no set matched the node.
+      while (count && bson_iter_next(&iter)) {
+         if (BSON_ITER_HOLDS_DOCUMENT(&iter) && bson_iter_recurse(&iter, &sub_iter)) {
+            node_matches_set = true;
+
+            // Iterate over the key/value pairs (tags) in the current set
+            while (bson_iter_next(&sub_iter) && BSON_ITER_HOLDS_UTF8(&sub_iter)) {
+               key = bson_iter_key(&sub_iter);
+               str = bson_iter_utf8(&sub_iter, &len);
+
+               // If any of the tags do not match, this node cannot satisfy this tag set.
+               if (!_contains_tag(node_tags, key, str, len)) {
+                   node_matches_set = false;
+                   break;
+               }
+            }
+
+            // This set matched, return the count as the score
+            if (node_matches_set) {
+                return count;
             }
+
+            // Decrement the score and try to match the next set.
+            count--;
          }
       }
       return -1;