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))