CDRIVER-3516 implement waitQueueTimeoutMS for client pools

Author: rcsanchez97

src/libmongoc/doc/connection-pooling.rst

@@ -51,4 +51,23 @@ When the driver is in pooled mode, your program's operations are unblocked as so
 
 The pool opens one connection per server for monitoring, and each client opens its own connection to each server it uses for application operations. The background thread re-scans the server topology roughly every 10 seconds. This interval is configurable with ``heartbeatFrequencyMS`` in the connection string. (See :symbol:`mongoc_uri_t`.)
 
+The connection string can also specify ``waitQueueTimeoutMS`` to limit the time that :symbol:`mongoc_client_pool_pop` will wait for a client from the pool.  (See :symbol:`mongoc_uri_t`.)  If ``waitQueueTimeoutMS`` is specified, then it is necessary to confirm that a client was actually returned:
+
+.. code-block:: c
+
+  mongoc_uri_t *uri = mongoc_uri_new (
+     "mongodb://hostA,hostB/?replicaSet=my_rs&waitQueueTimeoutMS=1000");
+
+  mongoc_client_pool_t *pool = mongoc_client_pool_new (uri);
+
+  mongoc_client_t *client = mongoc_client_pool_pop (pool);
+
+  if (client) {
+     /* use the client for operations ... */
+
+     mongoc_client_pool_push (pool, client);
+  } else {
+     /* take appropriate action for a timeout */
+  }
+
 See :ref:`connection_pool_options` to configure pool size and behavior, and see :symbol:`mongoc_client_pool_t` for an extended example of a multi-threaded program that uses the driver in pooled mode.

src/libmongoc/doc/mongoc_client_pool_pop.rst

@@ -11,7 +11,7 @@ Synopsis
   mongoc_client_t *
   mongoc_client_pool_pop (mongoc_client_pool_t *pool);
 
-Retrieve a :symbol:`mongoc_client_t` from the client pool, or create one. The total number of clients that can be created from this pool is limited by the URI option "maxPoolSize", default 100. If this number of clients has been created and all are in use, ``mongoc_client_pool_pop`` blocks until another thread returns a client with :symbol:`mongoc_client_pool_push()`.
+Retrieve a :symbol:`mongoc_client_t` from the client pool, or create one. The total number of clients that can be created from this pool is limited by the URI option "maxPoolSize", default 100. If this number of clients has been created and all are in use, ``mongoc_client_pool_pop`` blocks until another thread returns a client with :symbol:`mongoc_client_pool_push()`. If the "waitQueueTimeoutMS" URI option was specified with a positive value, then ``mongoc_client_pool_pop`` will return ``NULL`` when the timeout expires.
 
 The returned :symbol:`mongoc_client_t` must be returned to the pool with :symbol:`mongoc_client_pool_push()`.
 

src/libmongoc/doc/mongoc_uri_t.rst

@@ -193,7 +193,7 @@ MONGOC_URI_MAXPOOLSIZE                     maxpoolsize                       The
 MONGOC_URI_MINPOOLSIZE                     minpoolsize                       Deprecated. This option's behavior does not match its name, and its actual behavior will likely hurt performance.
 MONGOC_URI_MAXIDLETIMEMS                   maxidletimems                     Not implemented.
 MONGOC_URI_WAITQUEUEMULTIPLE               waitqueuemultiple                 Not implemented.
-MONGOC_URI_WAITQUEUETIMEOUTMS              waitqueuetimeoutms                Not implemented.
+MONGOC_URI_WAITQUEUETIMEOUTMS              waitqueuetimeoutms                The maximum time to wait for a client to become available from the pool.
 ========================================== ================================= =========================================================================================================================================================================================================================
 
 .. _mongoc_uri_t_write_concern_options:

src/libmongoc/src/mongoc/mongoc-client-pool.c

@@ -248,11 +248,21 @@ mongoc_client_t *
 mongoc_client_pool_pop (mongoc_client_pool_t *pool)
 {
    mongoc_client_t *client;
+   int32_t wait_queue_timeout_ms;
+   int64_t expire_at_ms = -1;
+   int64_t now_ms;
+   int r;
 
    ENTRY;
 
    BSON_ASSERT (pool);
 
+   wait_queue_timeout_ms = mongoc_uri_get_option_as_int32 (
+      pool->uri, MONGOC_URI_WAITQUEUETIMEOUTMS, -1);
+   if (wait_queue_timeout_ms > 0) {
+      expire_at_ms =
+         (bson_get_monotonic_time () / 1000) + wait_queue_timeout_ms;
+   }
    bson_mutex_lock (&pool->mutex);
 
 again:
@@ -262,12 +272,26 @@ mongoc_client_pool_pop (mongoc_client_pool_t *pool)
          _initialize_new_client (pool, client);
          pool->size++;
       } else {
-         mongoc_cond_wait (&pool->cond, &pool->mutex);
+         if (wait_queue_timeout_ms > 0) {
+            now_ms = bson_get_monotonic_time () / 1000;
+            if (now_ms < expire_at_ms) {
+               r = mongoc_cond_timedwait (
+                  &pool->cond, &pool->mutex, expire_at_ms - now_ms);
+               if (mongo_cond_ret_is_timedout (r)) {
+                  GOTO (done);
+               }
+            } else {
+               GOTO (done);
+            }
+         } else {
+            mongoc_cond_wait (&pool->cond, &pool->mutex);
+         }
          GOTO (again);
       }
    }
 
    _start_scanner_if_needed (pool);
+done:
    bson_mutex_unlock (&pool->mutex);
 
    RETURN (client);

src/libmongoc/src/mongoc/mongoc-thread-private.h

@@ -49,6 +49,10 @@ mongoc_cond_timedwait (pthread_cond_t *cond,
 
    return pthread_cond_timedwait (cond, mutex, &to);
 }
+static BSON_INLINE bool
+mongo_cond_ret_is_timedout (int ret) {
+   return ret == ETIMEDOUT;
+}
 #define mongoc_cond_destroy pthread_cond_destroy
 #else
 #define mongoc_cond_t CONDITION_VARIABLE
@@ -73,6 +77,10 @@ mongoc_cond_timedwait (mongoc_cond_t *cond,
       }
    }
 }
+static BSON_INLINE bool
+mongo_cond_ret_is_timedout (int ret) {
+   return ret == WSAETIMEDOUT;
+}
 #define mongoc_cond_signal WakeConditionVariable
 #define mongoc_cond_broadcast WakeAllConditionVariable
 static BSON_INLINE int

src/libmongoc/tests/test-mongoc-client-pool.c

@@ -41,6 +41,32 @@ test_mongoc_client_pool_try_pop (void)
    mongoc_client_pool_destroy (pool);
 }
 
+static void
+test_mongoc_client_pool_pop_timeout (void)
+{
+   mongoc_client_pool_t *pool;
+   mongoc_client_t *client;
+   mongoc_uri_t *uri;
+   int64_t start;
+   int64_t duration_usec;
+
+   uri = mongoc_uri_new (
+      "mongodb://127.0.0.1/?maxpoolsize=1&waitqueuetimeoutms=2000");
+   pool = mongoc_client_pool_new (uri);
+   client = mongoc_client_pool_pop (pool);
+   BSON_ASSERT (client);
+   start = bson_get_monotonic_time ();
+   BSON_ASSERT (!mongoc_client_pool_pop (pool));
+   duration_usec = bson_get_monotonic_time () - start;
+   /* There is a possibility that the wait is a few milliseconds short.  The
+    * assertion is structured like this since the timeout is a rough lower bound
+    * and some test environments (e.g., valgrind) might slow things down. */
+   BSON_ASSERT (duration_usec / 1000 >= 1990);
+   mongoc_client_pool_push (pool, client);
+   mongoc_uri_destroy (uri);
+   mongoc_client_pool_destroy (pool);
+}
+
 static void
 test_mongoc_client_pool_min_size_zero (void)
 {
@@ -341,6 +367,9 @@ test_client_pool_install (TestSuite *suite)
    TestSuite_Add (suite, "/ClientPool/basic", test_mongoc_client_pool_basic);
    TestSuite_Add (
       suite, "/ClientPool/try_pop", test_mongoc_client_pool_try_pop);
+   TestSuite_Add (suite,
+                  "/ClientPool/pop_timeout",
+                  test_mongoc_client_pool_pop_timeout);
    TestSuite_Add (suite,
                   "/ClientPool/min_size_zero",
                   test_mongoc_client_pool_min_size_zero);