CDRIVER-1571 simplify async command loop

mongoc_async_run() no longer returns "true" if there is more work to do:
it never returns early now since there is only one timeout for the whole
function. Also, make timeouts int64_t in all internal functions.

Author: ajdavis

src/mongoc/mongoc-async-cmd-private.h

@@ -80,7 +80,7 @@ mongoc_async_cmd_new (mongoc_async_t           *async,
                       const bson_t             *cmd,
                       mongoc_async_cmd_cb_t     cb,
                       void                     *cb_data,
-                      int32_t                   timeout_msec);
+                      int64_t                   timeout_msec);
 
 void
 mongoc_async_cmd_destroy (mongoc_async_cmd_t *acmd);

src/mongoc/mongoc-async-cmd.c

@@ -167,7 +167,7 @@ mongoc_async_cmd_new (mongoc_async_t           *async,
                       const bson_t             *cmd,
                       mongoc_async_cmd_cb_t     cb,
                       void                     *cb_data,
-                      int32_t                   timeout_msec)
+                      int64_t                   timeout_msec)
 {
    mongoc_async_cmd_t *acmd;
 

src/mongoc/mongoc-async-private.h

@@ -63,9 +63,9 @@ mongoc_async_new ();
 void
 mongoc_async_destroy (mongoc_async_t *async);
 
-bool
+void
 mongoc_async_run (mongoc_async_t *async,
-                  int32_t         timeout_msec);
+                  int64_t         timeout_msec);
 
 struct _mongoc_async_cmd *
 mongoc_async_cmd (mongoc_async_t          *async,
@@ -76,7 +76,7 @@ mongoc_async_cmd (mongoc_async_t          *async,
                   const bson_t            *cmd,
                   mongoc_async_cmd_cb_t    cb,
                   void                    *cb_data,
-                  int32_t                  timeout_msec);
+                  int64_t                  timeout_msec);
 
 BSON_END_DECLS
 

src/mongoc/mongoc-async.c

@@ -33,7 +33,7 @@ mongoc_async_cmd (mongoc_async_t           *async,
                   const bson_t             *cmd,
                   mongoc_async_cmd_cb_t     cb,
                   void                     *cb_data,
-                  int32_t                   timeout_msec)
+                  int64_t                   timeout_msec)
 {
    return mongoc_async_cmd_new (async, stream, setup, setup_ctx, dbname, cmd, cb,
                                 cb_data, timeout_msec);
@@ -60,9 +60,9 @@ mongoc_async_destroy (mongoc_async_t *async)
    bson_free (async);
 }
 
-bool
+void
 mongoc_async_run (mongoc_async_t *async,
-                  int32_t         timeout_msec)
+                  int64_t         timeout_msec)
 {
    mongoc_async_cmd_t *acmd, *tmp;
    mongoc_stream_poll_t *poller = NULL;
@@ -76,17 +76,15 @@ mongoc_async_run (mongoc_async_t *async,
    BSON_ASSERT (timeout_msec > 0);
 
    now = bson_get_monotonic_time ();
-   expire_at = now + ((int64_t) timeout_msec * 1000);
+   expire_at = now + timeout_msec * 1000;
    poll_size = 0;
 
-   for (;;) {
-      if (!async->ncmds) {
-         /* work complete */
-         break;
-      }
-
+   while (async->ncmds) {
+      /* ncmds grows if we discover a replica & start calling ismaster on it */
       if (poll_size < async->ncmds) {
-         poller = (mongoc_stream_poll_t *)bson_realloc (poller, sizeof (*poller) * async->ncmds);
+         poller = (mongoc_stream_poll_t *) bson_realloc (
+            poller, sizeof (*poller) * async->ncmds);
+
          poll_size = async->ncmds;
       }
 
@@ -145,7 +143,4 @@ mongoc_async_run (mongoc_async_t *async,
                 acmd->data, &acmd->error);
       mongoc_async_cmd_destroy (acmd);
    }
-
-   /* cancel the loop in the caller, mongoc_topology_scanner_work() */
-   return false;
 }

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

@@ -110,12 +110,12 @@ mongoc_topology_scanner_node_destroy (mongoc_topology_scanner_node_t *node,
 
 void
 mongoc_topology_scanner_start (mongoc_topology_scanner_t *ts,
-                               int32_t timeout_msec,
+                               int64_t timeout_msec,
                                bool obey_cooldown);
 
-bool
+void
 mongoc_topology_scanner_work (mongoc_topology_scanner_t *ts,
-                              int32_t                    timeout_msec);
+                              int64_t                    timeout_msec);
 
 void
 mongoc_topology_scanner_sum_errors (mongoc_topology_scanner_t *ts,

src/mongoc/mongoc-topology-scanner.c

@@ -532,7 +532,7 @@ mongoc_topology_scanner_node_setup (mongoc_topology_scanner_node_t *node,
 
 void
 mongoc_topology_scanner_start (mongoc_topology_scanner_t *ts,
-                               int32_t timeout_msec,
+                               int64_t timeout_msec,
                                bool obey_cooldown)
 {
    mongoc_topology_scanner_node_t *node, *tmp;
@@ -583,19 +583,11 @@ mongoc_topology_scanner_start (mongoc_topology_scanner_t *ts,
  *--------------------------------------------------------------------------
  */
 
-bool
+void
 mongoc_topology_scanner_work (mongoc_topology_scanner_t *ts,
-                              int32_t                    timeout_msec)
+                              int64_t                    timeout_msec)
 {
-   bool r;
-
-   r = mongoc_async_run (ts->async, timeout_msec);
-
-   if (! r) {
-      ts->in_progress = false;
-   }
-
-   return r;
+   mongoc_async_run (ts->async, timeout_msec);
 }
 
 /*

src/mongoc/mongoc-topology.c

@@ -273,43 +273,6 @@ mongoc_topology_destroy (mongoc_topology_t *topology)
    bson_free(topology);
 }
 
-/*
- *--------------------------------------------------------------------------
- *
- * _mongoc_topology_run_scanner --
- *
- *       Not threadsafe, the expectation is that we're either single
- *       threaded or only the background thread runs scans.
- *
- *       Crank the underlying scanner until we've timed out or finished.
- *
- * Returns:
- *       true if there is more work to do, false otherwise
- *
- *--------------------------------------------------------------------------
- */
-static bool
-_mongoc_topology_run_scanner (mongoc_topology_t *topology,
-                              int64_t        work_msec)
-{
-   int64_t now;
-   int64_t expire_at;
-   bool keep_going = true;
-
-   now = bson_get_monotonic_time ();
-   expire_at = now + (work_msec * 1000);
-
-   /* while there is more work to do and we haven't timed out */
-   while (keep_going && now <= expire_at) {
-      keep_going = mongoc_topology_scanner_work (topology->scanner, (expire_at - now) / 1000);
-
-      if (keep_going) {
-         now = bson_get_monotonic_time ();
-      }
-   }
-
-   return keep_going;
-}
 
 /*
  *--------------------------------------------------------------------------
@@ -327,8 +290,8 @@ _mongoc_topology_do_blocking_scan (mongoc_topology_t *topology, bson_error_t *er
                                   topology->connect_timeout_msec,
                                   true);
 
-   while (_mongoc_topology_run_scanner (topology,
-                                        topology->connect_timeout_msec)) {}
+   mongoc_topology_scanner_work (topology->scanner,
+                                 topology->connect_timeout_msec);
 
    /* Aggregate all scanner errors, if any */
    mongoc_topology_scanner_sum_errors (topology->scanner, error);
@@ -808,9 +771,8 @@ void * _mongoc_topology_run_background (void *data)
 
       /* scanning locks and unlocks the mutex itself until the scan is done */
       mongoc_mutex_unlock (&topology->mutex);
-
-      while (_mongoc_topology_run_scanner (topology,
-                                           topology->connect_timeout_msec)) {}
+      mongoc_topology_scanner_work (topology->scanner,
+                                    topology->connect_timeout_msec);
 
       mongoc_mutex_lock (&topology->mutex);
 

tests/test-mongoc-async.c

@@ -134,8 +134,7 @@ test_ismaster_impl (bool with_ssl)
                         TIMEOUT);
    }
 
-   while (mongoc_async_run (async, TIMEOUT)) {
-   }
+   mongoc_async_run (async, TIMEOUT);
 
    for (i = 0; i < NSERVERS; i++) {
       if (!results[i].finished) {

tests/test-mongoc-topology-scanner.c

@@ -57,7 +57,6 @@ _test_topology_scanner(bool with_ssl)
    int i;
    bson_t q = BSON_INITIALIZER;
    int finished = NSERVERS * 3;
-   bool more_to_do;
 
 #ifdef MONGOC_ENABLE_SSL
    mongoc_ssl_opt_t sopt = { 0 };
@@ -100,11 +99,7 @@ _test_topology_scanner(bool with_ssl)
 
    for (i = 0; i < 3; i++) {
       mongoc_topology_scanner_start (topology_scanner, TIMEOUT, false);
-
-      more_to_do = mongoc_topology_scanner_work (topology_scanner, TIMEOUT);
-
-      assert(! more_to_do);
-
+      mongoc_topology_scanner_work (topology_scanner, TIMEOUT);
       mongoc_topology_scanner_reset (topology_scanner);
    }