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