def p1(alert_id):
session = saq.database.DatabaseSession()
alert = session.query(Alert).filter(Alert.id == alert_id).one()
lock_uuid = acquire_lock(alert.uuid)
# tell parent to get the lock
sync0.set()
# wait for parent to signal
sync1.wait()
release_lock(alert.uuid, lock_uuid)
sync2.set()
def test_lock(self):
first_lock_uuid = str(uuid.uuid4())
second_lock_uuid = str(uuid.uuid4())
target_lock = str(uuid.uuid4())
self.assertTrue(acquire_lock(target_lock, first_lock_uuid))
self.assertFalse(acquire_lock(target_lock, second_lock_uuid))
self.assertTrue(acquire_lock(target_lock, first_lock_uuid))
release_lock(target_lock, first_lock_uuid)
self.assertTrue(acquire_lock(target_lock, second_lock_uuid))
self.assertFalse(acquire_lock(target_lock, first_lock_uuid))
release_lock(target_lock, second_lock_uuid)
def test_database_002_lock(self):
alert = self.insert_alert()
lock_uuid = acquire_lock(alert.uuid)
self.assertTrue(lock_uuid)
# something that was locked is locked
self.assertTrue(alert.is_locked())
# and can be locked again
self.assertEquals(lock_uuid, acquire_lock(alert.uuid, lock_uuid))
# can be unlocked
self.assertTrue(release_lock(alert.uuid, lock_uuid))
# truely is unlocked
self.assertFalse(alert.is_locked())
# cannot be unlocked again
self.assertFalse(release_lock(alert.uuid, lock_uuid))
# and can be locked again
self.assertTrue(acquire_lock(alert.uuid))
self.assertTrue(alert.is_locked())
def test_database_003_multiprocess_lock(self):
alert = self.insert_alert()
sync0 = Event()
sync1 = Event()
sync2 = Event()
def p1(alert_id):
session = saq.database.DatabaseSession()
alert = session.query(Alert).filter(Alert.id == alert_id).one()
lock_uuid = acquire_lock(alert.uuid)
# tell parent to get the lock
sync0.set()
# wait for parent to signal
sync1.wait()
release_lock(alert.uuid, lock_uuid)
sync2.set()
p = Process(target=p1, args=(alert.id, ))
p.start()
try:
sync0.wait()
# lock should already be locked
self.assertTrue(alert.is_locked())
# should not be able to lock the lock
self.assertFalse(acquire_lock(alert.uuid))
sync1.set()
sync2.wait()
# lock should be unlocked
self.assertFalse(alert.is_locked())
# and we should be able to lock it
lock_uuid = acquire_lock(alert.uuid)
self.assertTrue(uuid)
self.assertTrue(alert.is_locked())
self.assertTrue(release_lock(alert.uuid, lock_uuid))
self.assertFalse(alert.is_locked())
p.join()
p = None
finally:
if p:
p.terminate()
p.join()
