Current File : //usr/lib64/python2.7/site-packages/tornado/locks.pyc
�
��L]c @� s
d Z d d l m Z m Z m Z m Z d d d d d g Z d d l Z d d l m Z m
Z
d d
l m Z d e
f d � � YZ d e f d
� � YZ d e
f d � � YZ d e
f d � � YZ d e f d � � YZ d e f d � � YZ d e
f d � � YZ d S( sd
.. testsetup:: *
from tornado import ioloop, gen, locks
io_loop = ioloop.IOLoop.current()
i ( t absolute_importt divisiont print_functiont with_statementt Conditiont Eventt Semaphoret BoundedSemaphoret LockN( t gent ioloop( t Futuret _TimeoutGarbageCollectorc B� s e Z d Z d � Z d � Z RS( s� Base class for objects that periodically clean up timed-out waiters.
Avoids memory leak in a common pattern like:
while True:
yield condition.wait(short_timeout)
print('looping....')
c C� s t j � | _ d | _ d S( Ni ( t collectionst dequet _waiterst _timeouts( t self( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt __init__) s c C� sM | j d 7_ | j d k rI d | _ t j d � | j D� � | _ n d S( Ni id i c s� s! | ] } | j � s | Vq d S( N( t done( t .0t w( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pys <genexpr>3 s ( R R
R R ( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt _garbage_collect- s
( t __name__t
__module__t __doc__R R ( ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR s c B� sA e Z d Z d � Z d � Z d d � Z d d � Z d � Z RS( s� A condition allows one or more coroutines to wait until notified.
Like a standard `threading.Condition`, but does not need an underlying lock
that is acquired and released.
With a `Condition`, coroutines can wait to be notified by other coroutines:
.. testcode::
condition = locks.Condition()
@gen.coroutine
def waiter():
print("I'll wait right here")
yield condition.wait() # Yield a Future.
print("I'm done waiting")
@gen.coroutine
def notifier():
print("About to notify")
condition.notify()
print("Done notifying")
@gen.coroutine
def runner():
# Yield two Futures; wait for waiter() and notifier() to finish.
yield [waiter(), notifier()]
io_loop.run_sync(runner)
.. testoutput::
I'll wait right here
About to notify
Done notifying
I'm done waiting
`wait` takes an optional ``timeout`` argument, which is either an absolute
timestamp::
io_loop = ioloop.IOLoop.current()
# Wait up to 1 second for a notification.
yield condition.wait(timeout=io_loop.time() + 1)
...or a `datetime.timedelta` for a timeout relative to the current time::
# Wait up to 1 second.
yield condition.wait(timeout=datetime.timedelta(seconds=1))
The method raises `tornado.gen.TimeoutError` if there's no notification
before the deadline.
c C� s) t t | � j � t j j � | _ d S( N( t superR R R
t IOLoopt currentt io_loop( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR m s c C� s> d | j j f } | j r6 | d t | j � 7} n | d S( Ns <%ss waiters[%s]t >( t __class__R R t len( R t result( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt __repr__q s c � sr t � � � j j � � | rn � � f d � } t j j � � � j | | � � � j � � f d � � n � S( s� Wait for `.notify`.
Returns a `.Future` that resolves ``True`` if the condition is notified,
or ``False`` after a timeout.
c � s � j t � � j � d S( N( t
set_resultt FalseR ( ( R t waiter( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt
on_timeout� s
c � s
� j � � S( N( t remove_timeout( t _( R t timeout_handle( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt <lambda>� s ( R R t appendR
R R t add_timeoutt add_done_callback( R t timeoutR& ( ( R R R) R% s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt waitw s i c C� ss g } xH | rP | j rP | j j � } | j � s | d 8} | j | � q q Wx | D] } | j t � qX Wd S( s Wake ``n`` waiters.i N( R t popleftR R+ R# t True( R t nt waitersR% ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt notify� s
c C� s | j t | j � � d S( s Wake all waiters.N( R4 R R ( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt
notify_all� s N( R R R R R" t NoneR/ R4 R5 ( ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR 6 s 5 c B� sG e Z d Z d � Z d � Z d � Z d � Z d � Z d d � Z RS( so An event blocks coroutines until its internal flag is set to True.
Similar to `threading.Event`.
A coroutine can wait for an event to be set. Once it is set, calls to
``yield event.wait()`` will not block unless the event has been cleared:
.. testcode::
event = locks.Event()
@gen.coroutine
def waiter():
print("Waiting for event")
yield event.wait()
print("Not waiting this time")
yield event.wait()
print("Done")
@gen.coroutine
def setter():
print("About to set the event")
event.set()
@gen.coroutine
def runner():
yield [waiter(), setter()]
io_loop.run_sync(runner)
.. testoutput::
Waiting for event
About to set the event
Not waiting this time
Done
c C� s t � | _ d S( N( R t _future( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR � s c C� s& d | j j | j � r d n d f S( Ns <%s %s>t sett clear( R R t is_set( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR" � s c C� s
| j j � S( s- Return ``True`` if the internal flag is true.( R7 R ( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR: � s c C� s& | j j � s" | j j d � n d S( s� Set the internal flag to ``True``. All waiters are awakened.
Calling `.wait` once the flag is set will not block.
N( R7 R R# R6 ( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR8 � s c C� s" | j j � r t � | _ n d S( ss Reset the internal flag to ``False``.
Calls to `.wait` will block until `.set` is called.
N( R7 R R ( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR9 � s c C� s* | d k r | j St j | | j � Sd S( s� Block until the internal flag is true.
Returns a Future, which raises `tornado.gen.TimeoutError` after a
timeout.
N( R6 R7 R t with_timeout( R R. ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR/ � s N(
R R R R R" R: R8 R9 R6 R/ ( ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR � s % t _ReleasingContextManagerc B� s) e Z d Z d � Z d � Z d � Z RS( s� Releases a Lock or Semaphore at the end of a "with" statement.
with (yield semaphore.acquire()):
pass
# Now semaphore.release() has been called.
c C� s
| | _ d S( N( t _obj( R t obj( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR � s c C� s d S( N( ( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt __enter__� s c C� s | j j � d S( N( R= t release( R t exc_typet exc_valt exc_tb( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt __exit__� s ( R R R R R? RD ( ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR< � s c B� sG e Z d Z d d � Z d � Z d � Z d d � Z d � Z e Z RS( s� A lock that can be acquired a fixed number of times before blocking.
A Semaphore manages a counter representing the number of `.release` calls
minus the number of `.acquire` calls, plus an initial value. The `.acquire`
method blocks if necessary until it can return without making the counter
negative.
Semaphores limit access to a shared resource. To allow access for two
workers at a time:
.. testsetup:: semaphore
from collections import deque
from tornado import gen, ioloop
from tornado.concurrent import Future
# Ensure reliable doctest output: resolve Futures one at a time.
futures_q = deque([Future() for _ in range(3)])
@gen.coroutine
def simulator(futures):
for f in futures:
yield gen.moment
f.set_result(None)
ioloop.IOLoop.current().add_callback(simulator, list(futures_q))
def use_some_resource():
return futures_q.popleft()
.. testcode:: semaphore
sem = locks.Semaphore(2)
@gen.coroutine
def worker(worker_id):
yield sem.acquire()
try:
print("Worker %d is working" % worker_id)
yield use_some_resource()
finally:
print("Worker %d is done" % worker_id)
sem.release()
@gen.coroutine
def runner():
# Join all workers.
yield [worker(i) for i in range(3)]
io_loop.run_sync(runner)
.. testoutput:: semaphore
Worker 0 is working
Worker 1 is working
Worker 0 is done
Worker 2 is working
Worker 1 is done
Worker 2 is done
Workers 0 and 1 are allowed to run concurrently, but worker 2 waits until
the semaphore has been released once, by worker 0.
`.acquire` is a context manager, so ``worker`` could be written as::
@gen.coroutine
def worker(worker_id):
with (yield sem.acquire()):
print("Worker %d is working" % worker_id)
yield use_some_resource()
# Now the semaphore has been released.
print("Worker %d is done" % worker_id)
i c C� s; t t | � j � | d k r. t d � � n | | _ d S( Ni s$ semaphore initial value must be >= 0( R R R t
ValueErrort _value( R t value( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR E s c C� sz t t | � j � } | j d k r* d n d j | j � } | j rc d j | t | j � � } n d j | d d !| � S( Ni t lockeds unlocked,value:{0}s {0},waiters:{1}s <{0} [{1}]>i i����( R R R" RF t formatR R ( R t rest extra( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR" L s c C� sd | j d 7_ xN | j r_ | j j � } | j � s | j d 8_ | j t | � � Pq q Wd S( s* Increment the counter and wake one waiter.i N( RF R R0 R R# R< ( R R% ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR@ T s c � s� t � � � j d k r= � j d 8_ � j t � � � ne � j j � � | r� � � f d � } t j j � � � j | | � � � j
� � f d � � n � S( s� Decrement the counter. Returns a Future.
Block if the counter is zero and wait for a `.release`. The Future
raises `.TimeoutError` after the deadline.
i i c � s! � j t j � � � j � d S( N( t
set_exceptionR t TimeoutErrorR ( ( R R% ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR& r s c � s
� j � � S( N( R' ( R( ( R R) ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR* x s ( R RF R# R< R R+ R
R R R, R- ( R R. R& ( ( R R R) R% s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt acquiree s c C� s t d � � d S( NsP Use Semaphore like 'with (yield semaphore.acquire())', not like 'with semaphore'( t RuntimeError( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR? { s N(
R R R R R" R@ R6 RN R? RD ( ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR � s K c B� s# e Z d Z d d � Z d � Z RS( s: A semaphore that prevents release() being called too many times.
If `.release` would increment the semaphore's value past the initial
value, it raises `ValueError`. Semaphores are mostly used to guard
resources with limited capacity, so a semaphore released too many times
is a sign of a bug.
i c C� s& t t | � j d | � | | _ d S( NRG ( R R R t _initial_value( R RG ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR � s c C� s8 | j | j k r! t d � � n t t | � j � d S( s* Increment the counter and wake one waiter.s! Semaphore released too many timesN( RF RP RE R R R@ ( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR@ � s ( R R R R R@ ( ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR � s c B� sD e Z d Z d � Z d � Z d d � Z d � Z d � Z e Z RS( sE A lock for coroutines.
A Lock begins unlocked, and `acquire` locks it immediately. While it is
locked, a coroutine that yields `acquire` waits until another coroutine
calls `release`.
Releasing an unlocked lock raises `RuntimeError`.
`acquire` supports the context manager protocol:
>>> from tornado import gen, locks
>>> lock = locks.Lock()
>>>
>>> @gen.coroutine
... def f():
... with (yield lock.acquire()):
... # Do something holding the lock.
... pass
...
... # Now the lock is released.
c C� s t d d � | _ d S( NRG i ( R t _block( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR � s c C� s d | j j | j f S( Ns <%s _block=%s>( R R RQ ( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR" � s c C� s | j j | � S( s� Attempt to lock. Returns a Future.
Returns a Future, which raises `tornado.gen.TimeoutError` after a
timeout.
( RQ RN ( R R. ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyRN � s c C� s5 y | j j � Wn t k
r0 t d � � n Xd S( s� Unlock.
The first coroutine in line waiting for `acquire` gets the lock.
If not locked, raise a `RuntimeError`.
s release unlocked lockN( RQ R@ RE RO ( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR@ � s
c C� s t d � � d S( Ns7 Use Lock like 'with (yield lock)', not like 'with lock'( RO ( R ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR? � s N(
R R R R R" R6 RN R@ R? RD ( ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyR � s ( R t
__future__R R R R t __all__R
t tornadoR R
t tornado.concurrentR t objectR R R R< R R R ( ( ( s3 /usr/lib64/python2.7/site-packages/tornado/locks.pyt <module> s " dM�
Mini Shell