Support sessions in loadbalanced mode

kevinAlbs · kevinAlbs · commit b96d39a5b4bb · 2021-07-06T21:32:56.000-04:00
Sessions never expire
Sessions are always supported
diff --git a/src/libmongoc/CMakeLists.txt b/src/libmongoc/CMakeLists.txt
@@ -960,6 +960,7 @@ set (test-libmongoc-sources
    ${PROJECT_SOURCE_DIR}/tests/test-mongoc-interrupt.c
    ${PROJECT_SOURCE_DIR}/tests/test-mongoc-linux-distro-scanner.c
    ${PROJECT_SOURCE_DIR}/tests/test-mongoc-list.c
+   ${PROJECT_SOURCE_DIR}/tests/test-mongoc-loadbalanced.c
    ${PROJECT_SOURCE_DIR}/tests/test-mongoc-log.c
    ${PROJECT_SOURCE_DIR}/tests/test-mongoc-long-namespace.c
    ${PROJECT_SOURCE_DIR}/tests/test-mongoc-matcher.c
diff --git a/src/libmongoc/src/mongoc/mongoc-topology.c b/src/libmongoc/src/mongoc/mongoc-topology.c
@@ -1438,45 +1438,53 @@ _mongoc_topology_pop_server_session (mongoc_topology_t *topology,
    int64_t timeout;
    mongoc_server_session_t *ss = NULL;
    mongoc_topology_description_t *td;
+   bool loadbalanced;
 
    ENTRY;
 
    bson_mutex_lock (&topology->mutex);
 
    td = &topology->description;
    timeout = td->session_timeout_minutes;
+   loadbalanced = td->type == MONGOC_TOPOLOGY_LOADBALANCED;
 
-   if (timeout == MONGOC_NO_SESSIONS) {
-      /* if needed, connect and check for session timeout again */
-      if (!mongoc_topology_description_has_data_node (td)) {
-         bson_mutex_unlock (&topology->mutex);
-         if (!mongoc_topology_select_server_id (
-                topology, MONGOC_SS_READ, NULL, error)) {
-            RETURN (NULL);
-         }
+   /* When the topology type is LoadBalanced, sessions are always supported. */
+   if (!loadbalanced) {
+      if (timeout == MONGOC_NO_SESSIONS) {
+         /* if needed, connect and check for session timeout again */
+         if (!mongoc_topology_description_has_data_node (td)) {
+            bson_mutex_unlock (&topology->mutex);
+            if (!mongoc_topology_select_server_id (
+                   topology, MONGOC_SS_READ, NULL, error)) {
+               RETURN (NULL);
+            }
 
-         bson_mutex_lock (&topology->mutex);
-         timeout = td->session_timeout_minutes;
-      }
+            bson_mutex_lock (&topology->mutex);
+            timeout = td->session_timeout_minutes;
+         }
 
-      if (timeout == MONGOC_NO_SESSIONS) {
-         bson_mutex_unlock (&topology->mutex);
-         bson_set_error (error,
-                         MONGOC_ERROR_CLIENT,
-                         MONGOC_ERROR_CLIENT_SESSION_FAILURE,
-                         "Server does not support sessions");
-         RETURN (NULL);
+         if (timeout == MONGOC_NO_SESSIONS) {
+            bson_mutex_unlock (&topology->mutex);
+            bson_set_error (error,
+                            MONGOC_ERROR_CLIENT,
+                            MONGOC_ERROR_CLIENT_SESSION_FAILURE,
+                            "Server does not support sessions");
+            RETURN (NULL);
+         }
       }
    }
 
    while (topology->session_pool) {
       ss = topology->session_pool;
       CDL_DELETE (topology->session_pool, ss);
-      if (_mongoc_server_session_timed_out (ss, timeout)) {
-         _mongoc_server_session_destroy (ss);
-         ss = NULL;
-      } else {
-         break;
+      /* Sessions do not expire when the topology type is load balanced. */
+      if (!loadbalanced) {
+         if (_mongoc_server_session_timed_out (ss, timeout)) {
+            _mongoc_server_session_destroy (ss);
+            ss = NULL;
+         } else {
+            break;
+         }
       }
    }
 
@@ -1505,17 +1513,20 @@ _mongoc_topology_push_server_session (mongoc_topology_t *topology,
 {
    int64_t timeout;
    mongoc_server_session_t *ss;
+   bool loadbalanced;
 
    ENTRY;
 
    bson_mutex_lock (&topology->mutex);
 
    timeout = topology->description.session_timeout_minutes;
+   loadbalanced = topology->description.type == MONGOC_TOPOLOGY_LOADBALANCED;
 
    /* start at back of queue and reap timed-out sessions */
    while (topology->session_pool && topology->session_pool->prev) {
       ss = topology->session_pool->prev;
-      if (_mongoc_server_session_timed_out (ss, timeout)) {
+      /* Sessions do not expire when the topology type is load balanced. */
+      if (!loadbalanced && _mongoc_server_session_timed_out (ss, timeout)) {
          BSON_ASSERT (ss->next); /* silences clang scan-build */
          CDL_DELETE (topology->session_pool, ss);
          _mongoc_server_session_destroy (ss);
@@ -1526,8 +1537,10 @@ _mongoc_topology_push_server_session (mongoc_topology_t *topology,
    }
 
    /* If session is expiring or "dirty" (a network error occurred on it), do not
-    * return it to the pool. */
-   if (_mongoc_server_session_timed_out (server_session, timeout) ||
+    * return it to the pool. Sessions do not expire when the topology type is
+    * load balanced. */
+   if ((!loadbalanced &&
+        _mongoc_server_session_timed_out (server_session, timeout)) ||
        server_session->dirty) {
       _mongoc_server_session_destroy (server_session);
    } else {
diff --git a/src/libmongoc/tests/test-libmongoc.c b/src/libmongoc/tests/test-libmongoc.c
@@ -272,6 +272,8 @@ extern void
 test_bson_util_install (TestSuite *suite);
 extern void
 test_result_install (TestSuite *suite);
+extern void
+test_loadbalanced_install (TestSuite *suite);
 
 typedef struct {
    mongoc_log_level_t level;
@@ -1851,7 +1853,8 @@ mongoc_client_pool_t *
 test_framework_new_default_client_pool ()
 {
    mongoc_uri_t *test_uri = test_framework_get_uri ();
-   mongoc_client_pool_t *pool = test_framework_client_pool_new_from_uri (test_uri, NULL);
+   mongoc_client_pool_t *pool =
+      test_framework_client_pool_new_from_uri (test_uri, NULL);
 
    BSON_ASSERT (pool);
    test_framework_set_pool_ssl_opts (pool);
@@ -2905,6 +2908,7 @@ main (int argc, char *argv[])
    test_bson_match_install (&suite);
    test_bson_util_install (&suite);
    test_result_install (&suite);
+   test_loadbalanced_install (&suite);
 
    ret = TestSuite_Run (&suite);
 
diff --git a/src/libmongoc/tests/test-mongoc-loadbalanced.c b/src/libmongoc/tests/test-mongoc-loadbalanced.c
@@ -0,0 +1,101 @@
+/*
+ * Copyright 2020-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mongoc/mongoc.h"
+#include "mongoc/mongoc-client-session-private.h"
+#include "test-conveniences.h"
+#include "test-libmongoc.h"
+#include "TestSuite.h"
+
+static char *loadbalanced_uri (void) {
+   return test_framework_getenv ("SINGLE_MONGOS_LB_URI");
+}
+
+static void
+test_loadbalanced_sessions_supported (void *unused)
+{
+   mongoc_client_t *client;
+   mongoc_client_session_t *session;
+   char *uristr = loadbalanced_uri ();
+   bson_error_t error;
+
+   client = mongoc_client_new (uristr);
+   session = mongoc_client_start_session (client, NULL /* opts */, &error);
+   ASSERT_OR_PRINT (session, error);
+
+   mongoc_client_session_destroy (session);
+   bson_free (uristr);
+   mongoc_client_destroy (client);
+}
+
+static void
+test_loadbalanced_sessions_do_not_expire (void *unused)
+{
+   mongoc_client_t *client;
+   mongoc_client_session_t *session;
+   char *uristr = loadbalanced_uri ();
+   bson_error_t error;
+   bson_t *lsid1;
+   bson_t *lsid2;
+
+   client = mongoc_client_new (uristr);
+   session = mongoc_client_start_session (client, NULL /* opts */, &error);
+   ASSERT_OR_PRINT (session, error);
+
+   lsid1 = bson_copy (&session->server_session->lsid);
+   session->server_session->last_used_usec = 1;
+   mongoc_client_session_destroy (session);
+
+   session = mongoc_client_start_session (client, NULL /* opts */, &error);
+   ASSERT_OR_PRINT (session, error);
+   lsid2 = bson_copy (&session->server_session->lsid);
+   mongoc_client_session_destroy (session);
+
+   if (!bson_equal (lsid1, lsid2)) {
+      test_error ("Session not reused: %s != %s", tmp_json (lsid1), tmp_json (lsid2));
+   }
+
+   bson_destroy (lsid1);
+   bson_destroy (lsid2);
+   bson_free (uristr);
+   mongoc_client_destroy (client);
+}
+
+static int
+skip_if_not_loadbalanced (void)
+{
+   char *val = loadbalanced_uri ();
+   if (!val) {
+      return 0;
+   }
+   bson_free (val);
+   return 1;
+}
+
+void
+test_loadbalanced_install (TestSuite *suite)
+{
+   TestSuite_AddFull (suite, "/loadbalanced/sessions/supported",
+                      test_loadbalanced_sessions_supported,
+                      NULL /* ctx */,
+                      NULL /* dtor */,
+                      skip_if_not_loadbalanced);
+   TestSuite_AddFull (suite, "/loadbalanced/sessions/do_not_expire",
+                      test_loadbalanced_sessions_do_not_expire,
+                      NULL /* ctx */,
+                      NULL /* dtor */,
+                      skip_if_not_loadbalanced);
+}
