def test_lock_timeout(self):
saq.LOCK_TIMEOUT_SECONDS = 0
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.assertTrue(acquire_lock(target_lock, second_lock_uuid))
def test_database_003_expired(self):
# set locks to expire immediately
saq.LOCK_TIMEOUT_SECONDS = 0
alert = self.insert_alert()
lock_uuid = acquire_lock(alert.uuid)
self.assertTrue(lock_uuid)
# should expire right away
self.assertFalse(alert.is_locked())
# and we are able to lock it again
lock_uuid = acquire_lock(alert.uuid)
self.assertTrue(lock_uuid)
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_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()
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 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_clear_expired_locks(self, db, c):
# insert a lock that is already expired
saq.LOCK_TIMEOUT_SECONDS = 0
target = str(uuid.uuid4())
lock_uuid = str(uuid.uuid4())
self.assertTrue(acquire_lock(target, lock_uuid))
# this should clear out the lock
clear_expired_locks()
# make sure it's gone
c.execute("SELECT uuid FROM locks WHERE uuid = %s", (target,))
self.assertIsNone(c.fetchone())
def test_clear(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.initialize_storage()
root.details = {'hello': 'world'}
root.save()
self.assertTrue(os.path.exists(root.storage_dir))
lock_uuid = str(uuid.uuid4())
self.assertTrue(acquire_lock(root.uuid, lock_uuid))
result = ace_api.clear(root.uuid, lock_uuid)
self.assertFalse(os.path.exists(root.storage_dir))
def test_clear(self):
# first create something to clear
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.initialize_storage()
root.details = {'hello': 'world'}
with open(os.path.join(root.storage_dir, 'test.dat'), 'w') as fp:
fp.write('test')
file_observable = root.add_observable(F_FILE, 'test.dat')
root.save()
lock_uuid = str(uuid.uuid4())
# get a lock on it
self.assertTrue(acquire_lock(root.uuid, lock_uuid))
# clear it
result = self.client.get(
url_for('engine.clear', uuid=root.uuid, lock_uuid=lock_uuid))
self.assertEquals(result.status_code, 200)
# make sure it cleared
self.assertFalse(os.path.exists(root.storage_dir))
