cleanup

Author: blink1073

pymongo/asynchronous/pool.py

@@ -789,6 +789,7 @@ def __init__(
         # Also used for: clearing the wait queue
         self._max_connecting_cond = _async_create_condition(self.lock)
         self._pending = 0
+        self._max_connecting = self.opts.max_connecting
         self._client_id = client_id
         if self.enabled_for_cmap:
             assert self.opts._event_listeners is not None
@@ -993,7 +994,7 @@ async def remove_stale_sockets(self, reference_generation: int) -> None:
                 async with self._max_connecting_cond:
                     # If maxConnecting connections are already being created
                     # by this pool then try again later instead of waiting.
-                    if self._pending >= self.opts.max_connecting:
+                    if self._pending >= self._max_connecting:
                         return
                     self._pending += 1
                     incremented = True
@@ -1299,12 +1300,12 @@ async def _get_conn(
                 # to be checked back into the pool.
                 async with self._max_connecting_cond:
                     self._raise_if_not_ready(checkout_started_time, emit_event=False)
-                    while not (self.conns or self._pending < self.opts.max_connecting):
+                    while not (self.conns or self._pending < self._max_connecting):
                         timeout = deadline - time.monotonic() if deadline else None
                         if not await _async_cond_wait(self._max_connecting_cond, timeout):
                             # Timed out, notify the next thread to ensure a
                             # timeout doesn't consume the condition.
-                            if self.conns or self._pending < self.max_connecting:
+                            if self.conns or self._pending < self._max_connecting:
                                 self._max_connecting_cond.notify()
                             emitted_event = True
                             self._raise_wait_queue_timeout(checkout_started_time)

pymongo/synchronous/pool.py

@@ -787,6 +787,7 @@ def __init__(
         # Also used for: clearing the wait queue
         self._max_connecting_cond = _create_condition(self.lock)
         self._pending = 0
+        self._max_connecting = self.opts.max_connecting
         self._client_id = client_id
         if self.enabled_for_cmap:
             assert self.opts._event_listeners is not None
@@ -989,7 +990,7 @@ def remove_stale_sockets(self, reference_generation: int) -> None:
                 with self._max_connecting_cond:
                     # If maxConnecting connections are already being created
                     # by this pool then try again later instead of waiting.
-                    if self._pending >= self.opts.max_connecting:
+                    if self._pending >= self._max_connecting:
                         return
                     self._pending += 1
                     incremented = True
@@ -1295,12 +1296,12 @@ def _get_conn(
                 # to be checked back into the pool.
                 with self._max_connecting_cond:
                     self._raise_if_not_ready(checkout_started_time, emit_event=False)
-                    while not (self.conns or self._pending < self.opts.max_connecting):
+                    while not (self.conns or self._pending < self._max_connecting):
                         timeout = deadline - time.monotonic() if deadline else None
                         if not _cond_wait(self._max_connecting_cond, timeout):
                             # Timed out, notify the next thread to ensure a
                             # timeout doesn't consume the condition.
-                            if self.conns or self._pending < self.max_connecting:
+                            if self.conns or self._pending < self._max_connecting:
                                 self._max_connecting_cond.notify()
                             emitted_event = True
                             self._raise_wait_queue_timeout(checkout_started_time)

test/asynchronous/test_pooling.py

@@ -514,31 +514,6 @@ async def test_connection_timeout_message(self):
             str(error.exception),
         )
 
-    async def test_pool_check_backoff(self):
-        # Test that Pool recovers from two connection failures in a row.
-        # This exercises code at the end of Pool._check().
-        cx_pool = await self.create_pool(max_pool_size=1, connect_timeout=1, wait_queue_timeout=1)
-        self.addAsyncCleanup(cx_pool.close)
-
-        async with cx_pool.checkout() as conn:
-            # Simulate a closed socket without telling the Connection it's
-            # closed.
-            await conn.conn.close()
-
-        # Enable backoff.
-        cx_pool._backoff = 1
-
-        # Swap pool's address with a bad one.
-        address, cx_pool.address = cx_pool.address, ("foo.com", 1234)
-        with self.assertRaises(AutoReconnect):
-            async with cx_pool.checkout():
-                pass
-
-        # Back to normal, semaphore was correctly released.
-        cx_pool.address = address
-        async with cx_pool.checkout():
-            pass
-
     @async_client_context.require_failCommand_appName
     async def test_pool_backoff_preserves_existing_connections(self):
         client = await self.async_rs_or_single_client()
@@ -564,9 +539,6 @@ async def test_pool_backoff_preserves_existing_connections(self):
         async with self.fail_point(mock_connection_fail):
             await coll.find_one({})
 
-        # Make sure the pool is out of backoff state.
-        assert pool._backoff == 0
-
         # Make sure the existing socket was not affected.
         assert not t.sock.conn_closed()
 
@@ -575,16 +547,6 @@ async def test_pool_backoff_preserves_existing_connections(self):
         await t.join()
         await pool.close()
 
-    async def test_pool_backoff_limits_maxConnecting(self):
-        client = await self.async_rs_or_single_client(maxConnecting=10)
-        pool = await async_get_pool(client)
-        assert pool.max_connecting == 10
-        pool._backoff = 1
-        assert pool.max_connecting == 1
-        pool._backoff = 0
-        assert pool.max_connecting == 10
-        await client.close()
-
 
 class TestPoolMaxSize(_TestPoolingBase):
     async def test_max_pool_size(self):

test/test_pooling.py

@@ -512,31 +512,6 @@ def test_connection_timeout_message(self):
             str(error.exception),
         )
 
-    def test_pool_check_backoff(self):
-        # Test that Pool recovers from two connection failures in a row.
-        # This exercises code at the end of Pool._check().
-        cx_pool = self.create_pool(max_pool_size=1, connect_timeout=1, wait_queue_timeout=1)
-        self.addCleanup(cx_pool.close)
-
-        with cx_pool.checkout() as conn:
-            # Simulate a closed socket without telling the Connection it's
-            # closed.
-            conn.conn.close()
-
-        # Enable backoff.
-        cx_pool._backoff = 1
-
-        # Swap pool's address with a bad one.
-        address, cx_pool.address = cx_pool.address, ("foo.com", 1234)
-        with self.assertRaises(AutoReconnect):
-            with cx_pool.checkout():
-                pass
-
-        # Back to normal, semaphore was correctly released.
-        cx_pool.address = address
-        with cx_pool.checkout():
-            pass
-
     @client_context.require_failCommand_appName
     def test_pool_backoff_preserves_existing_connections(self):
         client = self.rs_or_single_client()
@@ -562,9 +537,6 @@ def test_pool_backoff_preserves_existing_connections(self):
         with self.fail_point(mock_connection_fail):
             coll.find_one({})
 
-        # Make sure the pool is out of backoff state.
-        assert pool._backoff == 0
-
         # Make sure the existing socket was not affected.
         assert not t.sock.conn_closed()
 
@@ -573,16 +545,6 @@ def test_pool_backoff_preserves_existing_connections(self):
         t.join()
         pool.close()
 
-    def test_pool_backoff_limits_maxConnecting(self):
-        client = self.rs_or_single_client(maxConnecting=10)
-        pool = get_pool(client)
-        assert pool.max_connecting == 10
-        pool._backoff = 1
-        assert pool.max_connecting == 1
-        pool._backoff = 0
-        assert pool.max_connecting == 10
-        client.close()
-
 
 class TestPoolMaxSize(_TestPoolingBase):
     def test_max_pool_size(self):