PYTHON-2503 Always use time.monotonic

For monotonic time needs.

Author: behackett

pymongo/client_session.py

@@ -98,6 +98,7 @@
 """
 
 import collections
+import time
 import uuid
 
 from collections.abc import Mapping as _Mapping
@@ -107,7 +108,6 @@
 from bson.son import SON
 from bson.timestamp import Timestamp
 
-from pymongo import monotonic
 from pymongo.errors import (ConfigurationError,
                             ConnectionFailure,
                             InvalidOperation,
@@ -336,7 +336,7 @@ def _max_time_expired_error(exc):
 
 def _within_time_limit(start_time):
     """Are we within the with_transaction retry limit?"""
-    return monotonic.time() - start_time < _WITH_TRANSACTION_RETRY_TIME_LIMIT
+    return time.monotonic() - start_time < _WITH_TRANSACTION_RETRY_TIME_LIMIT
 
 
 class ClientSession(object):
@@ -518,7 +518,7 @@ def callback(session, custom_arg, custom_kwarg=None):
 
         .. versionadded:: 3.9
         """
-        start_time = monotonic.time()
+        start_time = time.monotonic()
         while True:
             self.start_transaction(
                 read_concern, write_concern, read_preference,
@@ -797,7 +797,7 @@ def _txn_read_preference(self):
     def _apply_to(self, command, is_retryable, read_preference):
         self._check_ended()
 
-        self._server_session.last_use = monotonic.time()
+        self._server_session.last_use = time.monotonic()
         command['lsid'] = self._server_session.session_id
 
         if not self.in_transaction:
@@ -842,7 +842,7 @@ class _ServerSession(object):
     def __init__(self, generation):
         # Ensure id is type 4, regardless of CodecOptions.uuid_representation.
         self.session_id = {'id': Binary(uuid.uuid4().bytes, 4)}
-        self.last_use = monotonic.time()
+        self.last_use = time.monotonic()
         self._transaction_id = 0
         self.dirty = False
         self.generation = generation
@@ -856,7 +856,7 @@ def mark_dirty(self):
         self.dirty = True
 
     def timed_out(self, session_timeout_minutes):
-        idle_seconds = monotonic.time() - self.last_use
+        idle_seconds = time.monotonic() - self.last_use
 
         # Timed out if we have less than a minute to live.
         return idle_seconds > (session_timeout_minutes - 1) * 60

pymongo/monitor.py

@@ -16,14 +16,14 @@
 
 import atexit
 import threading
+import time
 import weakref
 
 from pymongo import common, periodic_executor
 from pymongo.errors import (NotMasterError,
                             OperationFailure,
                             _OperationCancelled)
 from pymongo.ismaster import IsMaster
-from pymongo.monotonic import time as _time
 from pymongo.periodic_executor import _shutdown_executors
 from pymongo.read_preferences import MovingAverage
 from pymongo.server_description import ServerDescription
@@ -208,7 +208,7 @@ def _check_server(self):
 
         Returns a ServerDescription.
         """
-        start = _time()
+        start = time.monotonic()
         try:
             try:
                 return self._check_once()
@@ -223,7 +223,7 @@ def _check_server(self):
             _sanitize(error)
             sd = self._server_description
             address = sd.address
-            duration = _time() - start
+            duration = time.monotonic() - start
             if self._publish:
                 awaited = sd.is_server_type_known and sd.topology_version
                 self._listeners.publish_server_heartbeat_failed(
@@ -265,7 +265,7 @@ def _check_with_socket(self, conn):
         Can raise ConnectionFailure or OperationFailure.
         """
         cluster_time = self._topology.max_cluster_time()
-        start = _time()
+        start = time.monotonic()
         if conn.more_to_come:
             # Read the next streaming isMaster (MongoDB 4.4+).
             response = IsMaster(conn._next_reply(), awaitable=True)
@@ -280,7 +280,7 @@ def _check_with_socket(self, conn):
         else:
             # New connection handshake or polling isMaster (MongoDB <4.4).
             response = conn._ismaster(cluster_time, None, None, None)
-        return response, _time() - start
+        return response, time.monotonic() - start
 
 
 class SrvMonitor(MonitorBase):
@@ -388,9 +388,9 @@ def _ping(self):
         with self._pool.get_socket({}) as sock_info:
             if self._executor._stopped:
                 raise Exception('_RttMonitor closed')
-            start = _time()
+            start = time.monotonic()
             sock_info.ismaster()
-            return _time() - start
+            return time.monotonic() - start
 
 
 # Close monitors to cancel any in progress streaming checks before joining

pymongo/monotonic.py

@@ -18,6 +18,7 @@
 import errno
 import socket
 import struct
+import time
 
 
 from bson import _decode_all_selective
@@ -31,7 +32,6 @@
                             ProtocolError,
                             _OperationCancelled)
 from pymongo.message import _UNPACK_REPLY, _OpMsg
-from pymongo.monotonic import time
 from pymongo.socket_checker import _errno_from_exception
 
 
@@ -185,7 +185,7 @@ def receive_message(sock_info, request_id, max_message_size=MAX_MESSAGE_SIZE):
     """Receive a raw BSON message or raise socket.error."""
     timeout = sock_info.sock.gettimeout()
     if timeout:
-        deadline = time() + timeout
+        deadline = time.monotonic() + timeout
     else:
         deadline = None
     # Ignore the response's request id.
@@ -236,7 +236,7 @@ def wait_for_read(sock_info, deadline):
                 # Wait up to 500ms for the socket to become readable and then
                 # check for cancellation.
                 if deadline:
-                    timeout = max(min(deadline - time(), _POLL_TIMEOUT), 0.001)
+                    timeout = max(min(deadline - time.monotonic(), _POLL_TIMEOUT), 0.001)
                 else:
                     timeout = _POLL_TIMEOUT
                 readable = sock_info.socket_checker.select(
@@ -245,7 +245,7 @@ def wait_for_read(sock_info, deadline):
                 raise _OperationCancelled('isMaster cancelled')
             if readable:
                 return
-            if deadline and time() > deadline:
+            if deadline and time.monotonic() > deadline:
                 raise socket.timeout("timed out")
 
 def _receive_data_on_socket(sock_info, length, deadline):

pymongo/network.py

@@ -18,8 +18,6 @@
 import time
 import weakref
 
-from pymongo.monotonic import time as _time
-
 
 class PeriodicExecutor(object):
     def __init__(self, interval, min_interval, target, name=None):
@@ -135,8 +133,8 @@ def _run(self):
             if self._skip_sleep:
                 self._skip_sleep = False
             else:
-                deadline = _time() + self._interval
-                while not self._stopped and _time() < deadline:
+                deadline = time.monotonic() + self._interval
+                while not self._stopped and time.monotonic() < deadline:
                     time.sleep(self._min_interval)
                     if self._event:
                         break  # Early wake.

pymongo/periodic_executor.py

@@ -12,6 +12,7 @@
 # implied.  See the License for the specific language governing
 # permissions and limitations under the License.
 
+import collections
 import contextlib
 import copy
 import ipaddress
@@ -20,7 +21,7 @@
 import socket
 import sys
 import threading
-import collections
+import time
 
 from bson import DEFAULT_CODEC_OPTIONS
 from bson.son import SON
@@ -48,7 +49,6 @@
                             OperationFailure,
                             PyMongoError)
 from pymongo.ismaster import IsMaster
-from pymongo.monotonic import time as _time
 from pymongo.monitoring import (ConnectionCheckOutFailedReason,
                                 ConnectionClosedReason)
 from pymongo.network import (command,
@@ -250,7 +250,7 @@ def _raise_connection_failure(address, error, msg_prefix=None):
 
 
 def _cond_wait(condition, deadline):
-    timeout = deadline - _time() if deadline else None
+    timeout = deadline - time.monotonic() if deadline else None
     return condition.wait(timeout)
 
 
@@ -502,7 +502,7 @@ def __init__(self, sock, pool, address, id):
         self.id = id
         self.authset = set()
         self.closed = False
-        self.last_checkin_time = _time()
+        self.last_checkin_time = time.monotonic()
         self.performed_handshake = False
         self.is_writable = False
         self.max_wire_version = MAX_WIRE_VERSION
@@ -862,14 +862,14 @@ def add_server_api(self, command, session):
             _add_to_command(command, self.opts.server_api)
 
     def update_last_checkin_time(self):
-        self.last_checkin_time = _time()
+        self.last_checkin_time = time.monotonic()
 
     def update_is_writable(self, is_writable):
         self.is_writable = is_writable
 
     def idle_time_seconds(self):
         """Seconds since this socket was last checked into its pool."""
-        return _time() - self.last_checkin_time
+        return time.monotonic() - self.last_checkin_time
 
     def _raise_connection_failure(self, error):
         # Catch *all* exceptions from socket methods and close the socket. In
@@ -1336,7 +1336,7 @@ def _get_socket(self, all_credentials):
 
         # Get a free socket or create one.
         if self.opts.wait_queue_timeout:
-            deadline = _time() + self.opts.wait_queue_timeout
+            deadline = time.monotonic() + self.opts.wait_queue_timeout
         else:
             deadline = None
 

pymongo/pool.py

@@ -18,6 +18,7 @@
 
 import socket as _socket
 import ssl as _stdlibssl
+import time
 
 from errno import EINTR as _EINTR
 
@@ -33,7 +34,6 @@
     VerificationError as _SIVerificationError)
 
 from pymongo.errors import CertificateError as _CertificateError
-from pymongo.monotonic import time as _time
 from pymongo.ocsp_support import (
     _load_trusted_ca_certs,
     _ocsp_callback)
@@ -98,14 +98,14 @@ def __init__(self, ctx, sock, suppress_ragged_eofs):
     def _call(self, call, *args, **kwargs):
         timeout = self.gettimeout()
         if timeout:
-            start = _time()
+            start = time.monotonic()
         while True:
             try:
                 return call(*args, **kwargs)
             except _RETRY_ERRORS:
                 self.socket_checker.select(
                     self, True, True, timeout)
-                if timeout and _time() - start > timeout:
+                if timeout and time.monotonic() - start > timeout:
                     raise _socket.timeout("timed out")
                 continue
 

pymongo/pyopenssl_context.py

@@ -14,10 +14,11 @@
 
 """Represent one server the driver is connected to."""
 
+import time
+
 from bson import EPOCH_NAIVE
 from pymongo.server_type import SERVER_TYPE
 from pymongo.ismaster import IsMaster
-from pymongo.monotonic import time as _time
 
 
 class ServerDescription(object):
@@ -67,7 +68,7 @@ def __init__(
         self._ls_timeout_minutes = ismaster.logical_session_timeout_minutes
         self._round_trip_time = round_trip_time
         self._me = ismaster.me
-        self._last_update_time = _time()
+        self._last_update_time = time.monotonic()
         self._error = error
         self._topology_version = ismaster.topology_version
         if error: