+++ /dev/null
-.. change::
- :tags: change, bug
-
- The internal clock used by the :class:`_pool.Pool` object is now
- time.monotonic_time() under Python 3. Under Python 2, time.time() is still
- used, which is legacy. This clock is used to measure the age of a
- connection against its starttime, and used in comparisons against the
- pool_timeout setting as well as the last time the pool was marked as
- invalid to determine if the connection should be recycled. Previously,
- time.time() was used which was subject to inaccuracies as a result of
- system clock changes as well as poor time resolution on windows.
"""
from collections import deque
+import time
import weakref
from .. import event
from .. import exc
from .. import log
from .. import util
-from ..util import monotonic_time
from ..util import threading
+
reset_rollback = util.symbol("reset_rollback")
reset_commit = util.symbol("reset_commit")
reset_none = util.symbol("reset_none")
"""
rec = getattr(connection, "_connection_record", None)
if not rec or self._invalidate_time < rec.starttime:
- self._invalidate_time = monotonic_time()
+ self._invalidate_time = time.time()
if _checkin and getattr(connection, "is_valid", False):
connection.invalidate(exception)
self.connection,
)
if soft:
- self._soft_invalidate_time = monotonic_time()
+ self._soft_invalidate_time = time.time()
else:
self.__close()
self.connection = None
recycle = False
# NOTE: the various comparisons here are assuming that measurable time
- # passes between these state changes. on Python 2, we are still using
- # time.time() which is not guaranteed to have millisecondsecond
- # precision, i.e. on Windows. For Python 3 we now use monotonic_time().
-
+ # passes between these state changes. however, time.time() is not
+ # guaranteed to have sub-second precision. comparisons of
+ # "invalidation time" to "starttime" should perhaps use >= so that the
+ # state change can take place assuming no measurable time has passed,
+ # however this does not guarantee correct behavior here as if time
+ # continues to not pass, it will try to reconnect repeatedly until
+ # these timestamps diverge, so in that sense using > is safer. Per
+ # https://stackoverflow.com/a/1938096/34549, Windows time.time() may be
+ # within 16 milliseconds accuracy, so unit tests for connection
+ # invalidation need a sleep of at least this long between initial start
+ # time and invalidation for the logic below to work reliably.
if self.connection is None:
self.info.clear()
self.__connect()
elif (
self.__pool._recycle > -1
- and monotonic_time() - self.starttime > self.__pool._recycle
+ and time.time() - self.starttime > self.__pool._recycle
):
self.__pool.logger.info(
"Connection %r exceeded timeout; recycling", self.connection
# creator fails, this attribute stays None
self.connection = None
try:
- self.starttime = monotonic_time()
+ self.starttime = time.time()
connection = pool._invoke_creator(self)
pool.logger.debug("Created new connection %r", connection)
self.connection = connection
"""
+import platform
import sys
from . import exclusions
def _running_on_windows(self):
return exclusions.LambdaPredicate(
- lambda: util.win32,
+ lambda: platform.system() == "Windows",
description="running on Windows",
)
- @property
- def millisecond_monotonic_time(self):
- """the util.monotonic_time() function must be millisecond accurate.
-
- Under Python 2 we can't guarantee this on Windows.
-
- """
- return exclusions.skip_if(
- lambda: util.win32 and sys.version_info < (3,)
- )
-
@property
def timing_intensive(self):
return exclusions.requires_tag("timing_intensive")
from .compat import iterbytes # noqa
from .compat import itertools_filter # noqa
from .compat import itertools_filterfalse # noqa
-from .compat import monotonic_time # noqa
from .compat import namedtuple # noqa
from .compat import next # noqa
from .compat import osx # noqa
from io import StringIO
from itertools import zip_longest
from time import perf_counter
- from time import monotonic as monotonic_time
-
from urllib.parse import (
quote_plus,
unquote_plus,
from cStringIO import StringIO as byte_buffer # noqa
from itertools import izip_longest as zip_longest # noqa
from time import clock as perf_counter # noqa
- from time import time as monotonic_time # noqa
from urllib import quote # noqa
from urllib import quote_plus # noqa
from urllib import unquote # noqa
)
def test_recycle(self):
- with patch("sqlalchemy.pool.base.monotonic_time") as mock:
+ with patch("sqlalchemy.pool.base.time.time") as mock:
mock.return_value = 10000
p = self._queuepool_fixture(
class MockReconnectTest(fixtures.TestBase):
- __requires__ = ("millisecond_monotonic_time",)
-
def setup(self):
self.dbapi = MockDBAPI()
[[call()], []],
)
- # checkout makes use of the same connection record. in
- # get_connection(), recycle should be enabled because
- # the age of the connection is older than the time at which
- # the invalidation occurred.
conn = self.db.connect()
- # therefore the two connections should both have been closed
- # when we connected again.
eq_(
[c.close.mock_calls for c in self.dbapi.connections],
[[call()], [call()], []],
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
