class SimpleBlockingQueue(object):
def __init__(self):
self.items = deque()
self.condition = Condition()
self.interrupted = False
def put(self, item):
with self.condition:
self.items.pushleft(item)
def take(self, block=False):
with self.condition:
if block:
while not self.items:
self.condition.wait()
if self.interrupted:
self.interrupted = False
return None
elif not self.items:
return None
return self.items.popright()
def interrupt(self):
with self.condition:
self.interrupted = True
self.condition.notifyAll()
class NextCritical(object):
def __init__(self, N):
self.condition = Condition()
self.N = N
self.calls = [0] * N
self.max_calls = 1
def is_ok(self, i):
with self.condition:
# print '%r / %d' % (self.calls, self.max_calls)
return self.calls[i] < self.max_calls
def wait(self, i):
with self.condition:
while not self.is_ok(i):
self.condition.wait()
def inc(self, i):
with self.condition:
if self.is_ok(i):
self.calls[i] += 1
if sum(self.calls) == self.max_calls * self.N:
self.max_calls += 1
self.condition.notifyAll()
else:
raise RuntimeError('Cannot inc while condition is not met.')
class KeyCache:
def __init__(self, capacity):
self.buffer_capacity = capacity
self.buffer_size = 0
self.cv = Condition()
self.q = []
self.producer_block_size = BLOCK_SIZE
def getKey(self):
self.cv.acquire()
while self.buffer_size == 0:
self.cv.wait()
item = self.q.pop(0)
self.buffer_size -= 1
self.cv.notifyAll()
self.cv.release()
return item
# insert multiple string equal to
def putKeys(self, items):
self.cv.acquire()
while self.buffer_size >= self.buffer_capacity - self.producer_block_size:
self.cv.wait()
self.q += items
self.buffer_size += len(items)
self.cv.notifyAll()
self.cv.release()
class Heartbeater(object):
interval = 5
def __init__(self, api, jobstep_id, interval=None):
self.api = api
self.jobstep_id = jobstep_id
self.cv = Condition()
self.finished = Event()
if interval is not None:
self.interval = interval
def wait(self):
with self.cv:
self.finished.clear()
while not self.finished.is_set():
data = self.api.get_jobstep(self.jobstep_id)
if data['status']['id'] == 'finished':
self.finished.set()
break
self.cv.wait(self.interval)
def close(self):
with self.cv:
self.finished.set()
self.cv.notifyAll()
class NiceTQueue():
def __init__(self):
self._list = []
self.condition = Condition()
def insert(self, index, item):
with self.condition:
self._list.insert(index, item)
self.condition.notifyAll()
def put(self, item):
with self.condition:
self._list.append(item)
self.condition.notifyAll()
def pop(self, index, timeout=None):
if not len(self._list):
with self.condition:
self.condition.wait(timeout)
if len(self._list) < index + 1:
raise queue.Empty()
return self._list.pop(index)
def get(self, timeout=None):
return self.pop(0, timeout)
def qsize(self):
return len(self._list)
def clear(self):
self._list.clear()
class PostBox(list):
def __init__(self, *a):
list.__init__(self, *a)
self.lever = Condition()
self.open = True
self.done = False
def wait(self):
self.lever.acquire()
if not self.done:
self.lever.wait()
self.lever.release()
return self.result
def wakeup(self, data):
self.result = data
self.lever.acquire()
self.done = True
self.lever.notifyAll()
self.lever.release()
def append(self, e):
self.lever.acquire()
if not self.open:
raise BoxClosedErr
list.append(self, e)
self.lever.release()
def close(self):
self.lever.acquire()
self.open = False
self.lever.release()
class DataQueue(Queue):
def __init__(self, count):
Queue.__init__(self)
self._count = count
self._cond = Condition()
def get(self, block=True, timeout=None):
self._cond.acquire()
if self.empty():
if not self._count:
raise Empty()
elif block:
self._cond.wait(timeout)
if self.empty() and not self._count:
self._cond.release()
raise Empty()
self._cond.release()
return Queue.get(self, block, timeout)
def put(self, data):
self._cond.acquire()
self._count = self._count - 1
Queue.put(self, data)
if self._count:
self._cond.notify()
else:
self._cond.notifyAll()
self._cond.release()
def remain(self):
return self._count + self.unfinished_tasks
class ConnectionPool:
def __init__(self, creator, max_active, *args, **kwargs):
self.max_active = max_active
self.queue = Queue(max_active)
self._lock = Condition()
self._connections = 0
self._creator = creator.connect
self._creator_constructor_args = (args, kwargs)
def get_connection(self):
self._lock.acquire()
try:
if self._connections < self.max_active:
conn = Connection(
self._creator(*self._creator_constructor_args[0],
**self._creator_constructor_args[1]), self)
self.queue.put(conn)
self._connections += 1
if self.queue.empty():
self._lock.wait()
return self.queue.get()
finally:
self._lock.release()
def release(self, conn):
self._lock.acquire()
try:
self.queue.put(conn)
self._lock.notifyAll()
finally:
self._lock.release()
def __del__(self):
while not self.queue.empty():
self.queue.get().close()
class File:
def __init__(self):
self.liste = []
self.cond = Condition()
self.premier = 0
self.dernier = 0
def affichage(self):
ch = "File = <"
for e in self.liste:
ch += str(e)
ch += ", "
ch += ">"
text0.config(text=ch)
def ajoute(self):
with self.cond:
while (len(self.liste) == 20):
self.cond.wait()
self.dernier = random.randint(1, 100)
self.liste.append(self.dernier)
self.cond.notifyAll()
def retrait(self):
with self.cond:
while (len(self.liste) == 0):
self.cond.wait()
self.premier = self.liste[0]
del self.liste[0]
self.cond.notifyAll()
class ReadWriteLock:
def __init__(self):
self.read_ready = Condition(Lock())
self.readers = 0
def acquire_read(self):
self.read_ready.acquire()
try:
self.readers += 1
finally:
self.read_ready.release()
def release_read(self):
self.read_ready.acquire()
try:
self.readers -= 1
if not self.readers:
self.read_ready.notifyAll()
finally:
self.read_ready.release()
def acquire_write(self):
self.read_ready.acquire()
while self.readers > 0:
self.read_ready.wait()
def release_write(self):
self.read_ready.release()
class ReadWriteLock():
def __init__(self):
self._readReady = Condition()
self._readers = 0
self._writes = 0
def acquireRead(self):
while self._writes > 0:
self._readReady.wait()
self._readReady.acquire()
try:
self._readers += 1
finally:
self._readReady.release()
def releaseRead(self):
self._readReady.acquire()
try:
self._readers -= 1
if not self._readers:
self._readReady.notifyAll()
finally:
self._readReady.release()
def acquireWrite(self):
self._writes += 1
self._readReady.acquire()
while self._readers > 0:
self._readReady.wait()
def releaseWrite(self):
self._writes -= 1
self._readReady.release()
class Observable:
def __init__(self):
self.mutex = RLock()
self.c = Condition(self.mutex)
self.observers = []
def register(self, observer):
with self.mutex:
if observer not in self.observers:
self.observers.append(observer)
def unregister(self, observer):
with self.mutex:
if observer in self.observers:
self.observers.remove(observer)
def unregister_all(self):
with self.mutex:
if self.observers:
del self.observers[:]
def update_observers(self, *args, **kwargs):
with self.mutex:
for observer in self.observers:
self.c.notifyAll()
observer.update(*args, **kwargs)
class File(): def __init__(self): self.file = [] self.Cond = Condition() def deposer(self,prod): with self.Cond : b = randint(0,100) prod.label["text"] = "Producteur : Ajout de l'entier " + str(b) + " dans la file" while(len(self.file)>20): prod.label["text"] = "Producteur : File pleine. En attente d'une place pour l'entier : " + str(b) self.Cond.wait() self.file.append(b) label["text"] = "File : " + str(self.file) self.Cond.notifyAll() def retirer(self,consom): with self.Cond : while(len(self.file)==0): consom.label["text"] = "Consommateurs "+ str(consom.n)+" : File vide. En attente de l'ajout d'un entier" self.Cond.wait() consom.label["text"] = "Consommateurs "+str(consom.n)+" : Retrait de l'entier " + str(self.file[0]) + " dans la file" r = self.file[0] self.file.remove(self.file[0]) consom.label["text"] = "Consommateurs "+str(consom.n)+" : Retrait de " + str(r) + " effectué" label["text"] = "File : " + str(self.file) self.Cond.notifyAll()
class locked_deque:
def __init__(self):
self._queue = deque()
self.cv = Condition()
return
def isempty(self):
return not bool(self._queue)
def pop(self):
with self.cv:
if (self.isempty()):
self.cv.wait()
if (self.isempty()):
return None
return self._queue.popleft()
def append(self, item):
with self.cv:
self._queue.append(item)
self.cv.notifyAll()
def wait(self, t):
with self.cv:
self.cv.wait(t)
class File():
def __init__(self):
self.file = []
self.Cond = Condition()
def deposer(self, prod):
with self.Cond:
b = randint(0, 100)
prod.label["text"] = "Producteur : ajout de l'entier " + str(b)
while (len(self.file) > 20):
prod.label["text"] = "Producteur : file pleine."
self.Cond.wait()
self.file.append(b)
fileLabel["text"] = "File : " + str(self.file)
self.Cond.notifyAll()
def retirer(self, consom):
with self.Cond:
while (len(self.file) == 0):
consom.label["text"] = "Consommateur " + str(
consom.n) + " : file vide."
self.Cond.wait()
r = self.file[0]
self.file.remove(self.file[0])
consom.label["text"] = "Consommateurs " + str(
consom.n) + " : retrait de " + str(r) + " effectué"
fileLabel["text"] = "File : " + str(self.file)
self.Cond.notifyAll()
class CountDownLatch:
def __init__(self, count):
self.count = count
self.condition = Condition()
def await_(self):
try:
self.condition.acquire()
while self.count > 0:
self.condition.wait()
finally:
self.condition.release()
def await_after(self, timeout):
try:
begin = time.time()
while begin + timeout >= time.time() and self.count > 0:
time.sleep(1)
finally:
pass
def countDown(self):
try:
self.condition.acquire()
self.count -= 1
if self.count <= 0:
self.condition.notifyAll()
finally:
self.condition.release()
def getCount(self):
return self.count
class MWPixelClock(object):
def __init__(self, conduitName):
self.conduit = Conduit(conduitName)
self.conduit.initialize()
self.conduit.register_local_event_code(0, '#stimDisplayUpdate')
self.conduit.register_callback_for_name('#stimDisplayUpdate',
self.receive_event)
self.codes = []
self.cond = Condition()
self.maxCodes = 100
def receive_event(self, event):
for s in event.data:
if s is None:
continue
if s.has_key('bit_code'):
self.cond.acquire()
self.codes.append((s['bit_code'], event.time / 1000000.))
# if len(self.codes) > 2:
# #logging.debug('MW bit_code = %i' % s['bit_code'])
# #print s['bit_code']
# #logging.debug("MW Delta: %s" % delta_code(self.codes[-1][0], self.codes[-2][0]))
while len(self.codes) > self.maxCodes:
self.codes.pop(0)
self.cond.notifyAll()
self.cond.release()
class WebcamVideoStream:
def __init__(self, logger, src=0):
self.stream = cv2.VideoCapture(src)
(self.grabbed, self.frame) = self.stream.read()
self.stopped = False
self.should_capture_frame = Condition()
self.logger = logger
self.n = 0
def start(self):
Thread(target=self.update, args=()).start()
return self
def update(self):
while not self.stopped:
self.n += 1
logger.debug('taking a shot! %s' % self.n)
self.frame = cv2.cvtColor(self.stream.read()[1], cv2.COLOR_BGR2RGB)
logger.debug('took a shot! %s' % self.n)
with self.should_capture_frame:
self.should_capture_frame.wait()
def read(self):
to_return = numpy.copy(self.frame)
with self.should_capture_frame:
self.should_capture_frame.notifyAll()
logger.debug('returning a frame %s' % self.n)
return to_return
def stop(self):
self.stopped = True
class Semaphore(object):
def __init__(self, count):
self.count = count
self.left = count
self.cond = Condition()
def acquire(self):
self.cond.acquire()
while self.left == 0:
self.cond.wait()
self.left -= 1
self.cond.notifyAll()
self.cond.release()
def release(self):
self.cond.acquire()
while self.left == self.count:
self.cond.wait()
self.left += 1
self.cond.notifyAll()
self.cond.release()
class PeriodicWorker(Thread):
def __init__(self, func, config, duration=600, logger=cherrypy.log, logDB=None):
# use default RLock from condition
# Lock wan't be shared between the instance used only for wait
# func : function or callable object pointer
self.wakeUp = Condition()
self.stopFlag = False
self.taskFunc = func
self.config = config
self.duration = duration
self.logger = logger
self.logDB = logDB
try:
name = func.__name__
print(name)
except AttributeError:
name = func.__class__.__name__
print(name)
Thread.__init__(self, name=name)
cherrypy.engine.subscribe('start', self.start, priority=100)
cherrypy.engine.subscribe('stop', self.stop, priority=100)
def stop(self):
self.wakeUp.acquire()
self.stopFlag = True
self.wakeUp.notifyAll()
self.wakeUp.release()
def run(self):
while not self.stopFlag:
self.wakeUp.acquire()
try:
self.taskFunc(self.config)
self.heartBeatInfoToLogDB()
except Exception as e:
self.logger.error("Periodic Thread ERROR %s.%s %s"
% (getattr(e, "__module__", "__builtins__"),
e.__class__.__name__, str(e)))
traceMsg = traceback.format_exc()
for line in traceMsg.rstrip().split("\n"):
self.logger.error(" " + line)
self.heartBeatErrorToLogDB(traceMsg)
self.wakeUp.wait(self.duration)
self.wakeUp.release()
def heartBeatInfoToLogDB(self):
if self.logDB:
self.logDB.delete(mtype="error", this_thread=True)
self.logDB.post(mtype="info")
return
def heartBeatErrorToLogDB(self, msg):
if self.logDB:
self.logDB.post(msg=msg, mtype="error")
return
class CountDownLatch:
"""
CountDownLatch can be used for async testing
"""
def __init__(self, count=1):
self.count = count
self.condition = Condition()
def awaits(self, timeout=None, to_count=0):
try:
self.condition.acquire()
start = datetime.now()
while self.count > to_count:
self.condition.wait(timeout / 10) # divides each step by 10
if timeout is not None:
spent = (datetime.now() - start).seconds
if spent > timeout:
raise Exception(
"timeout after waiting for %d seconds!" % spent)
finally:
self.condition.release()
def count_down(self):
try:
self.condition.acquire()
self.count -= 1
self.condition.notifyAll()
finally:
self.condition.release()
def get_count(self):
return self.count
class ReaderWriterLock:
def __init__(self):
self.condition_variable = Condition()
self.writer_working = False
self.readers = 0
def acquire_reader_lock(self):
self.condition_variable.acquire()
while self.writer_working is True:
self.condition_variable.wait()
self.readers += 1
self.condition_variable.release()
def release_reader_lock(self):
self.condition_variable.acquire()
self.readers -= 1
if self.readers == 0:
self.condition_variable.notifyAll()
self.condition_variable.release()
def acquire_writer_lock(self):
self.condition_variable.acquire()
while self.readers != 0 or self.writer_working is True:
self.condition_variable.wait()
self.writer_working = True
self.condition_variable.release()
def release_writer_lock(self):
self.condition_variable.acquire()
self.writer_working = False
self.condition_variable.notifyAll()
self.condition_variable.release()
class AsyncChannel:
# yes, i believe this is just Queue ... i was new to python and couldn't find it
def __init__(self, buffer_size=1):
self.buffer = []
self.max_items = buffer_size
self.lock = Lock()
self.not_empty = Condition(self.lock)
self.not_full = Condition(self.lock)
def get(self):
self.lock.acquire()
while len(self.buffer) == 0:
self.not_empty.wait()
val = self.buffer.pop(0)
self.not_full.notifyAll()
self.lock.release()
return val
def put(self, val):
self.lock.acquire()
while len(self.buffer) == self.max_items:
self.not_full.wait()
self.buffer.append(val)
self.not_empty.notifyAll()
self.lock.release()
class CountDownLatch(object):
def __init__(self, count):
self._count = count
self._lock = Condition()
def count_down(self):
self._lock.acquire()
self._count -= 1
if self._count <= 0:
self._lock.notifyAll()
self._lock.release()
def wait(self, wait_secs=None):
self._lock.acquire()
if wait_secs is not None:
self._lock.wait(wait_secs)
else:
while self._count > 0:
self._lock.wait()
self._lock.release()
def get_count(self):
self._lock.acquire()
count = self._count
self._lock.release()
return count
class Primitive:
def __init__(self, gate=1, lock=None):
self._Lock = lock if lock is not None else RLock()
self._WakeUp = Condition(self._Lock)
self._Gate = Semaphore(gate)
def getLock(self):
return self._Lock
def __enter__(self):
return self._Lock.__enter__()
def __exit__(self, exc_type, exc_value, traceback):
return self._Lock.__exit__(exc_type, exc_value, traceback)
@synchronized
def sleep(self, timeout=None, function=None, arguments=()):
self._WakeUp.wait(timeout)
if function is not None:
return function(*arguments)
# await is a reserved word in Python 3, use "wakeup" instead
@synchronized
def wakeup(self, n=1, all=False, function=None, arguments=()):
if function is not None:
function(*arguments)
if all:
self._WakeUp.notifyAll()
else:
self._WakeUp.notify(n)
class CountLatch(object):
"""Synchronization primitive with the capacity to count and latch.
Counting up latches, while reaching zero when counting down un-latches.
.. note::
The CountLatch class has been included in Sardana
on a provisional basis. Backwards incompatible changes
(up to and including removal of the module) may occur if
deemed necessary by the core developers.
"""
def __init__(self):
self.count = 0
self.condition = Condition()
def count_up(self):
"""Count up."""
self.condition.acquire()
self.count += 1
self.condition.release()
def count_down(self, _=None):
"""Count down."""
self.condition.acquire()
self.count -= 1
if self.count <= 0:
self.condition.notifyAll()
self.condition.release()
def wait(self):
"""Wait until the counter reaches zero."""
self.condition.acquire()
while self.count > 0:
self.condition.wait()
self.condition.release()
class IncomingMsgHandler(Runnable):
def __init__(self, devs, output):
self._queue = []
self._lock = Condition()
self._devs = devs
self._output = output
self._close = False
def getMsg(self):
with self._lock:
while len(self._queue) == 0:
self._lock.wait()
if self._close: return None
return self._queue.pop(0)
def close(self):
with self._lock:
self._close = True
self._lock.notifyAll()
def addMsg(self, msg):
with self._lock:
self._queue.append(msg)
self._lock.notifyAll()
def run(self):
while not self._close:
msg = self.getMsg()
if msg is not None:
IncomingDataHandler(msg, self._output, self._devs).run()
class Barrier(object):
def __init__(self, size):
self.barrier_size = size
self.reached_thread = 0
self.released_thread = 0
self.condition_variable = Condition()
def reached(self):
self.condition_variable.acquire()
# block any new threads from proceeding until all the threads
# have reached the previous Barrier having been released
while self.reached_thread == self.barrier_size:
self.condition_variable.wait()
self.reached_thread += 1
if self.reached_thread == self.barrier_size:
self.released_thread = self.barrier_size
else:
while self.reached_thread < self.barrier_size:
self.condition_variable.wait()
self.released_thread -= 1
if self.released_thread == 0:
self.reached_thread = 0
print("{0} released".format(current_thread().getName()))
self.condition_variable.notifyAll()
self.condition_variable.release()
class _EventRef(object):
""" Helper class which acts as a threading.Event, but which can be used
to pass a reference when signaling the event.
"""
def __init__(self):
self._cond = Condition(Lock())
self._flag = False
self._ref = None
def isSet(self):
return self._flag
def set(self, ref):
with self._cond:
assert self._ref is None
self._ref = ref
self._flag = True
self._cond.notifyAll()
def get(self, timeout=None):
with self._cond:
if not self._flag:
self._cond.wait(timeout)
if not self._flag:
raise TimeoutExceeded('Could not get the reference.')
return self._ref
def clear(self, ref):
with self._cond:
self._ref = None
self._flag = False
def test_lock2():
cond = Condition()
testlock = TestLock()
def invork_init_pool():
cond.acquire()
try:
cond.wait()
testlock.init_pool()
finally:
cond.release()
threads = []
for i in range(100):
t = Thread(target=invork_init_pool)
t.start()
threads.append(t)
with cond:
cond.notifyAll()
for thread in threads:
thread.join()
print(testlock.get_pool())
