CDRIVER-1933 smallest maxStalenessSeconds is 90

Revert code to parse "idleWritePeriodMillis" from ismaster, and revert
changes that allowed maxStalenessSeconds to be a float. Sync JSON tests
from specs repo.

Author: ajdavis

doc/mongoc_read_prefs_get_max_staleness_seconds.page

@@ -12,7 +12,7 @@
 
   <section id="synopsis">
     <title>Synopsis</title>
-    <synopsis><code mime="text/x-csrc"><![CDATA[double
+    <synopsis><code mime="text/x-csrc"><![CDATA[int64_t
 mongoc_read_prefs_get_max_staleness_seconds (const mongoc_read_prefs_t *read_prefs);
 ]]></code></synopsis>
   </section>
@@ -26,7 +26,7 @@ mongoc_read_prefs_get_max_staleness_seconds (const mongoc_read_prefs_t *read_pre
 
   <section id="description">
     <title>Description</title>
-    <p>Clients estimate the staleness of each secondary, and select for reads only those secondaries whose estimated staleness is less than or equal to maxStalenessSeconds. The default is -1, meaning no maximum staleness.</p>
+    <p>Clients estimate the staleness of each secondary, and select for reads only those secondaries whose estimated staleness is less than or equal to maxStalenessSeconds. The default is <code>MONGOC_NO_MAX_STALENESS</code>.</p>
   </section>
 
 </page>

doc/mongoc_read_prefs_set_max_staleness_seconds.page

@@ -14,14 +14,14 @@
     <title>Synopsis</title>
     <synopsis><code mime="text/x-csrc"><![CDATA[void
 mongoc_read_prefs_set_max_staleness_seconds (mongoc_read_prefs_t *read_prefs,
-                                             double               max_staleness_seconds);]]></code></synopsis>
+                                             int64_t              max_staleness_seconds);]]></code></synopsis>
   </section>
 
   <section id="parameters">
     <title>Parameters</title>
     <table>
       <tr><td><p>read_prefs</p></td><td><p>A <code xref="mongoc_read_prefs_t">mongoc_read_prefs_t</code>.</p></td></tr>
-      <tr><td><p>max_staleness_seconds</p></td><td><p>A positive number or -1 (meaning no maximum).</p></td></tr>
+      <tr><td><p>max_staleness_seconds</p></td><td><p>A positive integer or <code>MONGOC_NO_MAX_STALENESS</code>.</p></td></tr>
     </table>
   </section>
 

doc/mongoc_read_prefs_t.page

@@ -61,6 +61,13 @@
     <p>All interfaces use the same member selection logic to choose the member to which to direct read operations, basing the choice on read preference mode and tag sets.</p>
   </section>
 
+  <section id="max-staleness-seconds">
+    <title>Max Staleness</title>
+    <p>When connected to replica set running MongoDB 3.4 or later, the driver estimates the staleness of each secondary based on lastWriteDate values provided in server isMaster responses.</p>
+    <p>Max Staleness is the maximum replication lag in seconds (wall clock time) that a secondary can suffer and still be eligible for reads. The default is <code>MONGOC_NO_MAX_STALENESS</code>, which disables staleness checks. Otherwise, it must be a positive integer at least <code>MONGOC_SMALLEST_MAX_STALENESS_SECONDS</code> (90 seconds).</p>
+    <p>Max Staleness is also supported by sharded clusters of replica sets if all servers run MongoDB 3.4 or later.</p>
+  </section>
+
   <links type="topic" groups="function" style="2column">
     <title>Functions</title>
   </links>

src/mongoc/mongoc-read-prefs-private.h

@@ -29,13 +29,11 @@
 
 BSON_BEGIN_DECLS
 
-#define NO_MAX_STALENESS (-1.0)
-
 struct _mongoc_read_prefs_t
 {
    mongoc_read_mode_t mode;
    bson_t             tags;
-   double             max_staleness_seconds;
+   int64_t            max_staleness_seconds;
 };
 
 

src/mongoc/mongoc-read-prefs.c

@@ -29,7 +29,7 @@ mongoc_read_prefs_new (mongoc_read_mode_t mode)
    read_prefs = (mongoc_read_prefs_t *)bson_malloc0(sizeof *read_prefs);
    read_prefs->mode = mode;
    bson_init(&read_prefs->tags);
-   read_prefs->max_staleness_seconds = NO_MAX_STALENESS;
+   read_prefs->max_staleness_seconds = MONGOC_NO_MAX_STALENESS;
 
    return read_prefs;
 }
@@ -98,7 +98,7 @@ mongoc_read_prefs_add_tag (mongoc_read_prefs_t *read_prefs,
 }
 
 
-double
+int64_t
 mongoc_read_prefs_get_max_staleness_seconds (const mongoc_read_prefs_t *read_prefs)
 {
    BSON_ASSERT (read_prefs);
@@ -109,7 +109,7 @@ mongoc_read_prefs_get_max_staleness_seconds (const mongoc_read_prefs_t *read_pre
 
 void
 mongoc_read_prefs_set_max_staleness_seconds (mongoc_read_prefs_t *read_prefs,
-                                             double               max_staleness_seconds)
+                                             int64_t              max_staleness_seconds)
 {
    BSON_ASSERT (read_prefs);
 
@@ -127,13 +127,13 @@ mongoc_read_prefs_is_valid (const mongoc_read_prefs_t *read_prefs)
     */
    if (read_prefs->mode == MONGOC_READ_PRIMARY) {
       if (!bson_empty(&read_prefs->tags) ||
-          read_prefs->max_staleness_seconds != NO_MAX_STALENESS) {
+          read_prefs->max_staleness_seconds != MONGOC_NO_MAX_STALENESS) {
          return false;
       }
    }
 
-   if (read_prefs->max_staleness_seconds != NO_MAX_STALENESS &&
-       read_prefs->max_staleness_seconds <= 0.0) {
+   if (read_prefs->max_staleness_seconds != MONGOC_NO_MAX_STALENESS &&
+       read_prefs->max_staleness_seconds <= 0) {
       return false;
    }
 
@@ -198,7 +198,7 @@ _apply_read_preferences_mongos (const mongoc_read_prefs_t *read_prefs,
    const bson_t *tags = NULL;
    bson_t child;
    const char *mode_str;
-   double max_staleness_seconds;
+   int64_t max_staleness_seconds;
 
    mode = mongoc_read_prefs_get_mode (read_prefs);
    if (read_prefs) {
@@ -257,9 +257,9 @@ _apply_read_preferences_mongos (const mongoc_read_prefs_t *read_prefs,
       max_staleness_seconds = mongoc_read_prefs_get_max_staleness_seconds (
          read_prefs);
 
-      if (max_staleness_seconds != NO_MAX_STALENESS) {
-         bson_append_double (&child, "maxStalenessSeconds", 19,
-                             max_staleness_seconds);
+      if (max_staleness_seconds != MONGOC_NO_MAX_STALENESS) {
+         bson_append_int64 (&child, "maxStalenessSeconds", 19,
+                            max_staleness_seconds);
       }
 
       bson_append_document_end (result->query_with_read_prefs, &child);

src/mongoc/mongoc-read-prefs.h

@@ -28,6 +28,9 @@
 BSON_BEGIN_DECLS
 
 
+#define MONGOC_NO_MAX_STALENESS -1
+#define MONGOC_SMALLEST_MAX_STALENESS_SECONDS 90
+
 typedef struct _mongoc_read_prefs_t mongoc_read_prefs_t;
 
 
@@ -61,10 +64,10 @@ BSON_API
 void                 mongoc_read_prefs_add_tag                   (mongoc_read_prefs_t       *read_prefs,
                                                                   const bson_t              *tag);
 BSON_API
-double               mongoc_read_prefs_get_max_staleness_seconds (const mongoc_read_prefs_t *read_prefs);
+int64_t              mongoc_read_prefs_get_max_staleness_seconds (const mongoc_read_prefs_t *read_prefs);
 BSON_API
 void                 mongoc_read_prefs_set_max_staleness_seconds (mongoc_read_prefs_t       *read_prefs,
-                                                                  double                     max_staleness_seconds);
+                                                                  int64_t                    max_staleness_seconds);
 BSON_API
 bool                 mongoc_read_prefs_is_valid                  (const mongoc_read_prefs_t *read_prefs);
 

src/mongoc/mongoc-server-description-private.h

@@ -24,7 +24,7 @@
 #define MONGOC_DEFAULT_WRITE_BATCH_SIZE 1000
 #define MONGOC_DEFAULT_BSON_OBJ_SIZE 16 * 1024 * 1024
 #define MONGOC_DEFAULT_MAX_MSG_SIZE 48000000
-#define MONGOC_DEFAULT_IDLE_WRITE_PERIOD_MS 10 * 1000
+#define MONGOC_IDLE_WRITE_PERIOD_MS 10 * 1000
 
 /* represent a server or topology with no replica set config version */
 #define MONGOC_NO_SET_VERSION -1
@@ -75,7 +75,6 @@ struct _mongoc_server_description_t
    int64_t                          set_version;
    bson_oid_t                       election_id;
    int64_t                          last_write_date_ms;
-   int64_t                          idle_write_period_ms;
 };
 
 void

src/mongoc/mongoc-server-description.c

@@ -63,7 +63,6 @@ mongoc_server_description_reset (mongoc_server_description_t *sd)
    sd->max_bson_obj_size = MONGOC_DEFAULT_BSON_OBJ_SIZE;
    sd->max_write_batch_size = MONGOC_DEFAULT_WRITE_BATCH_SIZE;
    sd->last_write_date_ms = -1;
-   sd->idle_write_period_ms = -1;
 
    /* always leave last ismaster in an init-ed state until we destroy sd */
    bson_destroy (&sd->last_is_master);
@@ -121,7 +120,6 @@ mongoc_server_description_init (mongoc_server_description_t *sd,
    sd->max_bson_obj_size = MONGOC_DEFAULT_BSON_OBJ_SIZE;
    sd->max_write_batch_size = MONGOC_DEFAULT_WRITE_BATCH_SIZE;
    sd->last_write_date_ms = -1;
-   sd->idle_write_period_ms = -1;
 
    bson_init_static (&sd->hosts, kMongocEmptyBson, sizeof (kMongocEmptyBson));
    bson_init_static (&sd->passives, kMongocEmptyBson, sizeof (kMongocEmptyBson));
@@ -699,13 +697,13 @@ mongoc_server_description_filter_stale (mongoc_server_description_t **sds,
                                         int64_t                       heartbeat_frequency_ms,
                                         const mongoc_read_prefs_t    *read_prefs)
 {
-   double max_staleness_seconds;
+   int64_t max_staleness_seconds;
    size_t i;
 
    int64_t heartbeat_frequency_usec;
    int64_t max_last_write_date_usec;
    int64_t staleness_usec;
-   double max_staleness_usec;
+   int64_t max_staleness_usec;
 
    if (!read_prefs) {
       /* NULL read_prefs is PRIMARY, no maxStalenessSeconds to filter by */
@@ -715,11 +713,11 @@ mongoc_server_description_filter_stale (mongoc_server_description_t **sds,
    max_staleness_seconds = mongoc_read_prefs_get_max_staleness_seconds (
       read_prefs);
 
-   if (max_staleness_seconds == NO_MAX_STALENESS) {
+   if (max_staleness_seconds == MONGOC_NO_MAX_STALENESS) {
       return;
    }
 
-   BSON_ASSERT (max_staleness_seconds >= 0);
+   BSON_ASSERT (max_staleness_seconds > 0);
    max_staleness_usec = max_staleness_seconds * 1000 * 1000;
    heartbeat_frequency_usec = heartbeat_frequency_ms * 1000;
 

src/mongoc/mongoc-topology-description-private.h

@@ -102,7 +102,7 @@ mongoc_topology_description_all_sds_have_write_date (
 bool
 _mongoc_topology_description_validate_max_staleness (
    const mongoc_topology_description_t *td,
-   double                               max_staleness_seconds,
+   int64_t                              max_staleness_seconds,
    bson_error_t                        *error);
 
 void

src/mongoc/mongoc-topology-description.c

@@ -505,78 +505,44 @@ mongoc_topology_description_all_sds_have_write_date (const mongoc_topology_descr
 bool
 _mongoc_topology_description_validate_max_staleness (
    const mongoc_topology_description_t *td,
-   double                               max_staleness_seconds,
+   int64_t                              max_staleness_seconds,
    bson_error_t                        *error)
 {
-   int i;
-   mongoc_server_description_t *sd;
-   int64_t idle_write_period_ms = -1;
-
-   if (max_staleness_seconds == NO_MAX_STALENESS) {
-      return true;
-   }
-
-   /* The isMaster response of a replica set member running some future
-    * MongoDB version may contain idleWritePeriodMillis. Choose the
-    * primary's value or else the most recently updated secondary's value,
-    * according to the Server Selection Spec.
+   mongoc_topology_description_type_t td_type;
+
+   /* Server Selection Spec: A driver MUST raise an error if the TopologyType
+    * is ReplicaSetWithPrimary or ReplicaSetNoPrimary and either of these
+    * conditions is false:
+    *
+    * maxStalenessSeconds * 1000 >= heartbeatFrequencyMS + idleWritePeriodMS
+    * maxStalenessSeconds >= smallestMaxStalenessSeconds
     */
-   if (td->type == MONGOC_TOPOLOGY_RS_WITH_PRIMARY) {
-      mongoc_server_description_t *primary = NULL;
-
-      for (i = 0; i < td->servers->items_len; i++) {
-         sd = (mongoc_server_description_t *) mongoc_set_get_item (
-            td->servers, i);
-
-         if (sd->type == MONGOC_SERVER_RS_PRIMARY) {
-            primary = sd;
-            break;
-         }
-      }
-
-      BSON_ASSERT (primary);
-
-      idle_write_period_ms = primary->idle_write_period_ms;
-   } else if (td->type == MONGOC_TOPOLOGY_RS_NO_PRIMARY) {
-      mongoc_server_description_t *last_updated = NULL;
-
-      for (i = 0; i < td->servers->items_len; i++) {
-         sd = (mongoc_server_description_t *) mongoc_set_get_item (
-            td->servers, i);
 
-         if (sd->type != MONGOC_SERVER_RS_SECONDARY) {
-            continue;
-         }
-
-         if (!last_updated ||
-             sd->last_update_time_usec > last_updated->last_update_time_usec) {
-            last_updated = sd;
-         }
-      }
-
-      if (!last_updated) {
-         /* no secondaries */
-         return true;
-      }
+   td_type = td->type;
 
-      idle_write_period_ms = last_updated->idle_write_period_ms;
-   } else {
-      /* topology is not a replica set */
+   if (td_type != MONGOC_TOPOLOGY_RS_WITH_PRIMARY &&
+       td_type != MONGOC_TOPOLOGY_RS_NO_PRIMARY) {
       return true;
    }
 
-   if (idle_write_period_ms == -1) {
-      idle_write_period_ms = MONGOC_DEFAULT_IDLE_WRITE_PERIOD_MS;
+   if (max_staleness_seconds * 1000 <
+      td->heartbeat_msec + MONGOC_IDLE_WRITE_PERIOD_MS) {
+      bson_set_error (error, MONGOC_ERROR_COMMAND,
+                      MONGOC_ERROR_COMMAND_INVALID_ARG,
+                      "maxStalenessSeconds is set to %" PRId64
+                      ", it must be at least heartbeatFrequencyMS (%" PRId64
+                      ") + server's idle write period (%d seconds)",
+                      max_staleness_seconds, td->heartbeat_msec,
+                      MONGOC_IDLE_WRITE_PERIOD_MS / 1000);
+      return false;
    }
 
-   if (max_staleness_seconds * 1000 <
-       td->heartbeat_msec + idle_write_period_ms) {
+   if (max_staleness_seconds < MONGOC_SMALLEST_MAX_STALENESS_SECONDS) {
       bson_set_error (error, MONGOC_ERROR_COMMAND,
                       MONGOC_ERROR_COMMAND_INVALID_ARG,
-                      "maxStalenessSeconds must be at least"
-                      " heartbeatFrequencyMS (%" PRId64 ") +"
-                      " server's idleWritePeriodMillis (%" PRId64 ")",
-                      td->heartbeat_msec, idle_write_period_ms);
+                      "maxStalenessSeconds is set to %" PRId64
+                      ", it must be at least %d seconds", max_staleness_seconds,
+                      MONGOC_SMALLEST_MAX_STALENESS_SECONDS);
       return false;
    }