def setUp(self):
self._builtin_open = builtins.open
self._failure_countdown = None
self._retry_count = None
self._errno = EMOCKEDFAILURE
lock_dir = TemporaryDirectory()
self.addCleanup(lock_dir.cleanup)
self._lock = Lock(os.path.join(lock_dir.name, 'test.lck'))
def setUp(self):
self._builtin_open = builtins.open
self._failure_countdown = None
self._retry_count = None
self._errno = EMOCKEDFAILURE
fd, self._lockfile = tempfile.mkstemp('.lck')
os.close(fd)
self._lock = Lock(self._lockfile)
def setUp(self):
self._saved_CLOCK_SLOP = flufl.lock._lockfile.CLOCK_SLOP
flufl.lock._lockfile.CLOCK_SLOP = datetime.timedelta(seconds=0)
fd, self._lockfile = tempfile.mkstemp('.lck')
os.close(fd)
self._lifetime = datetime.timedelta(seconds=1)
self._lock1 = Lock(self._lockfile, lifetime=self._lifetime)
self._lock2 = Lock(self._lockfile, lifetime=self._lifetime)
class ErrnoRetryTests(unittest.TestCase):
def setUp(self):
self._builtin_open = builtins.open
self._failure_countdown = None
self._retry_count = None
self._errno = EMOCKEDFAILURE
fd, self._lockfile = tempfile.mkstemp('.lck')
os.close(fd)
self._lock = Lock(self._lockfile)
def tearDown(self):
self._disable()
try:
self._lock.unlock()
except NotLockedError:
pass
try:
os.remove(self._lockfile)
except OSError as error:
if error.errno != errno.ENOENT:
raise
def _enable(self):
builtins.open = self._testable_open
self._failure_countdown = 3
self._retry_count = 0
def _disable(self):
builtins.open = self._builtin_open
def _testable_open(self, *args, **kws):
if self._failure_countdown <= 0:
return self._builtin_open(*args, **kws)
self._failure_countdown -= 1
self._retry_count += 1
raise TestableEnvironmentError(self._errno)
def test_retry_errno_api(self):
self.assertEqual(self._lock.retry_errnos, [])
self._lock.retry_errnos = [EMOCKEDFAILURE, EOTHERMOCKEDFAILURE]
self.assertEqual(self._lock.retry_errnos,
[EMOCKEDFAILURE, EOTHERMOCKEDFAILURE])
del self._lock.retry_errnos
self.assertEqual(self._lock.retry_errnos, [])
def test_retries(self):
# Test that _read() will retry when a given errno is encountered.
self._lock.lock()
self._lock.retry_errnos = [self._errno]
self._enable()
self.assertTrue(self._lock.is_locked)
# The _read() trigged by the .is_locked call should have been retried.
self.assertEqual(self._retry_count, 3)
class ErrnoRetryTests(unittest.TestCase):
def setUp(self):
self._builtin_open = builtins.open
self._failure_countdown = None
self._retry_count = None
self._errno = EMOCKEDFAILURE
fd, self._lockfile = tempfile.mkstemp('.lck')
os.close(fd)
self._lock = Lock(self._lockfile)
def tearDown(self):
self._disable()
try:
self._lock.unlock()
except NotLockedError:
pass
try:
os.remove(self._lockfile)
except OSError as error:
if error.errno != errno.ENOENT:
raise
def _enable(self):
builtins.open = self._testable_open
self._failure_countdown = 3
self._retry_count = 0
def _disable(self):
builtins.open = self._builtin_open
def _testable_open(self, *args, **kws):
if self._failure_countdown <= 0:
return self._builtin_open(*args, **kws)
self._failure_countdown -= 1
self._retry_count += 1
raise TestableEnvironmentError(self._errno)
def test_retry_errno_api(self):
self.assertEqual(self._lock.retry_errnos, [])
self._lock.retry_errnos = [EMOCKEDFAILURE, EOTHERMOCKEDFAILURE]
self.assertEqual(self._lock.retry_errnos,
[EMOCKEDFAILURE, EOTHERMOCKEDFAILURE])
del self._lock.retry_errnos
self.assertEqual(self._lock.retry_errnos, [])
def test_retries(self):
# Test that _read() will retry when a given errno is encountered.
self._lock.lock()
self._lock.retry_errnos = [self._errno]
self._enable()
self.assertTrue(self._lock.is_locked)
# The _read() trigged by the .is_locked call should have been retried.
self.assertEqual(self._retry_count, 3)
def setUp(self):
self._builtin_open = builtins.open
self._failure_countdown = None
self._retry_count = None
self._errno = EMOCKEDFAILURE
fd, self._lockfile = tempfile.mkstemp('.lck')
os.close(fd)
self._lock = Lock(self._lockfile)
class ErrnoRetryTests(unittest.TestCase):
def setUp(self):
self._builtin_open = builtins.open
self._failure_countdown = None
self._retry_count = None
self._errno = EMOCKEDFAILURE
lock_dir = TemporaryDirectory()
self.addCleanup(lock_dir.cleanup)
self._lock = Lock(os.path.join(lock_dir.name, 'test.lck'))
def tearDown(self):
with suppress(NotLockedError):
self._lock.unlock()
def _testable_open(self, *args, **kws):
if self._failure_countdown <= 0:
return self._builtin_open(*args, **kws)
self._failure_countdown -= 1
self._retry_count += 1
raise TestableEnvironmentError(self._errno)
def test_retry_errno_api(self):
self.assertEqual(self._lock.retry_errnos, [])
self._lock.retry_errnos = [EMOCKEDFAILURE, EOTHERMOCKEDFAILURE]
self.assertEqual(self._lock.retry_errnos,
[EMOCKEDFAILURE, EOTHERMOCKEDFAILURE])
del self._lock.retry_errnos
self.assertEqual(self._lock.retry_errnos, [])
def test_retries(self):
# Test that _read() will retry when a given errno is encountered.
self._lock.lock()
self._lock.retry_errnos = [self._errno]
self._failure_countdown = 3
self._retry_count = 0
with patch('builtins.open', self._testable_open):
self.assertTrue(self._lock.is_locked)
# The _read() trigged by the .is_locked call should have been retried.
self.assertEqual(self._retry_count, 3)
def setUp(self):
lock_dir = TemporaryDirectory()
self.addCleanup(lock_dir.cleanup)
self._lock = Lock(os.path.join(lock_dir.name, 'test.lck'))
class LifetimeTests(unittest.TestCase):
def setUp(self):
self._saved_CLOCK_SLOP = flufl.lock._lockfile.CLOCK_SLOP
flufl.lock._lockfile.CLOCK_SLOP = datetime.timedelta(seconds=0)
fd, self._lockfile = tempfile.mkstemp('.lck')
os.close(fd)
self._lifetime = datetime.timedelta(seconds=1)
self._lock1 = Lock(self._lockfile, lifetime=self._lifetime)
self._lock2 = Lock(self._lockfile, lifetime=self._lifetime)
def tearDown(self):
flufl.lock._lockfile.CLOCK_SLOP = self._saved_CLOCK_SLOP
try:
self._lock1.unlock()
except NotLockedError:
pass
try:
self._lock2.unlock()
except NotLockedError:
pass
try:
os.remove(self._lockfile)
except OSError as error:
if error.errno != errno.ENOENT:
raise
def test_no_break(self):
self._lock1.lock()
with self.assertRaises(TimeOutError):
self._lock2.lock(timeout=datetime.timedelta(seconds=0))
def test_break(self):
self._lock1.lock()
time.sleep(self._lifetime.seconds)
self._lock2.lock(timeout=datetime.timedelta(seconds=0))
self.assertTrue(self._lock2.is_locked)
self.assertFalse(self._lock1.is_locked)
