def __init__(self, server_type, server_name, parent_instance, accesses, restrictions=()): """ CoordServer(server_type,server_name[, parent_instance[,accesses]]) -> CoordServer * server_type is a member of an enumerator listing the types of server * server_name is the name of the server * parent_instance is a member of CoordInstance, and can be later * accesses is a sequence of instances of Access * restrictions is a sequence of restrictions. For instance, a server for FPGAs, etc. modified with the "parent" property. """ object.__init__(self) # Server information self._server_type = server_type self._status = False self._accesses_lock = lock.RWLock() self._accesses_read_lock = self._accesses_lock.read_lock() self._accesses_write_lock = self._accesses_lock.write_lock() self._version = 0 self._accesses = list(accesses) self._restrictions = list(restrictions) # Addressing information self._name = server_name self._parent = parent_instance self._address = CoordAddress.CoordAddress(self._parent.parent.name, self._parent.name, self._name)
def __init__(self): object.__init__(self) self._servers = {} self._servers_lock = lock.RWLock() self._servers_read_lock = self._servers_lock.read_lock() self._servers_write_lock = self._servers_lock.write_lock()
def test_rw_lock_only_one_write(self): rwlock = lock.RWLock() wlock = rwlock.write_lock() evt1 = threading.Event() evt2 = threading.Event() wlock.acquire() class RLockThread(threading.Thread): def run(self): evt1.set() wlock.acquire() evt2.set() thread = RLockThread() thread.setDaemon(True) thread.start() evt1.wait(SHORT_TIMEOUT) self.assertTrue(evt1.isSet()) evt2.wait(VERY_SHORT_TIMEOUT) self.assertFalse(evt2.isSet()) # Cleaning up wlock.release() thread.join()
def test_rw_lock_reentrant_one_write(self): rwlock = lock.RWLock() wlock = rwlock.write_lock() evt1 = threading.Event() evt2 = threading.Event() wlock.acquire() class RLockThread(threading.Thread): def run(self): evt1.set() wlock.acquire() evt2.set() thread = RLockThread() thread.setDaemon(True) thread.start() evt1.wait(SHORT_TIMEOUT) self.assertTrue(evt1.isSet()) evt2.wait(VERY_SHORT_TIMEOUT) self.assertFalse(evt2.isSet()) # I don't have any problem wlock.acquire() # And I can release and the other thread is still there wlock.release() evt2.wait(VERY_SHORT_TIMEOUT) self.assertFalse(evt2.isSet()) # The second time it works wlock.release() evt2.wait(SHORT_TIMEOUT) self.assertTrue(evt2.isSet()) thread.join()
def test_rw_write_write(self): rwlock = lock.RWLock() wlock = rwlock.write_lock() wlock.acquire() wlock.release() wlock.acquire() wlock.release()
def test_rw_lock_reentrant_reading_while_write_locked(self): rwlock = lock.RWLock() rlock = rwlock.read_lock() wlock = rwlock.write_lock() wlock.acquire() rlock.acquire() rlock.release() wlock.release()
def __init__(self): object.__init__(self) self._machines_lock = lock.RWLock() self._machines_read_lock = self._machines_lock.read_lock() self._machines_write_lock = self._machines_lock.write_lock() #self._version will increase each time something is changed self._version = 0 #_machines is a set of CoordMachines self._machines = {}
def __init__(self, map=None): """ CoordinationMapController([map]) Creates a new instance of the map """ object.__init__(self) self._map_lock = lock.RWLock() self._map_read_lock = self._map_lock.read_lock() self._map_write_lock = self._map_lock.write_lock() self._map = map
def test_rw_lock_basic(self): rwlock = lock.RWLock() rlock = rwlock.read_lock() wlock = rwlock.write_lock() rlock.acquire() rlock.release() wlock.acquire() wlock.release()
def __init__(self, machine_id, parent_map): object.__init__(self) # A machine is a set of CoordInstances self._instances_lock = lock.RWLock() self._instances_read_lock = self._instances_lock.read_lock() self._instances_write_lock = self._instances_lock.write_lock() self._instances = {} self._version = 0 # Addressing information self.name = machine_id self.parent = parent_map self.address = CoordAddress.CoordAddress(machine_id, '', '')
def __init__(self, instance_name, parent_machine): object.__init__(self) # An instance is a set of CoordServers self._servers_lock = lock.RWLock() self._servers_read_lock = self._servers_lock.read_lock() self._servers_write_lock = self._servers_lock.write_lock() self._servers = {} self._version = 0 # Addressing information self.name = instance_name self._parent = parent_machine self._address = CoordAddress.CoordAddress(self._parent.name, self.name, '')
def test_rw_lock_multiple_reads(self): rwlock = lock.RWLock() rlock = rwlock.read_lock() evt = threading.Event() rlock.acquire() class RLockThread(threading.Thread): def run(self): rlock.acquire() evt.set() thread = RLockThread() thread.setDaemon(True) thread.start() evt.wait(SHORT_TIMEOUT) self.assertTrue(evt.isSet()) thread.join()
def test_rw_lock_read_read_write(self): rwlock = lock.RWLock() rlock = rwlock.read_lock() wlock = rwlock.write_lock() evt1r = threading.Event() evt2r = threading.Event() evt3r = threading.Event() evt4r = threading.Event() class RLockThread(threading.Thread): def run(self): evt1r.set() rlock.acquire() evt2r.set() evt3r.wait(SHORT_TIMEOUT * 2) rlock.release() evt4r.set() evt1w = threading.Event() evt2w = threading.Event() evt3w = threading.Event() class WLockThread(threading.Thread): def run(self): evt1w.set() evt2w.wait(SHORT_TIMEOUT * 2) wlock.acquire() evt3w.set() threadR = RLockThread() threadR.setDaemon(True) threadW = WLockThread() threadW.setDaemon(True) rlock.acquire() threadR.start() threadW.start() evt1r.wait(SHORT_TIMEOUT) self.assertTrue(evt1r.isSet()) evt2r.wait(SHORT_TIMEOUT) self.assertTrue(evt2r.isSet()) evt1w.wait(SHORT_TIMEOUT) self.assertTrue(evt1w.isSet()) evt2w.set() evt3w.wait(VERY_SHORT_TIMEOUT) self.assertFalse(evt3w.isSet()) # Everybody did an acquire # WLockThread is locked until # we do a couple of releases rlock.release() # Not yet... evt3w.wait(VERY_SHORT_TIMEOUT) self.assertFalse(evt3w.isSet()) evt3r.set() evt4r.wait(VERY_SHORT_TIMEOUT) self.assertTrue(evt4r.isSet()) # Now yes evt3w.wait(VERY_SHORT_TIMEOUT) self.assertTrue(evt3w.isSet())