ó ¨œž[c@`sddlmZmZmZddlZddlmZddlmZm Z ddl m Z m Z dddd d gZ d efd „ƒYZdefd „ƒYZdefd„ƒYZdefd„ƒYZdefd„ƒYZd efd„ƒYZd efd„ƒYZdS(i(tabsolute_importtdivisiontprint_functionN(tCancelledError(tgentioloop(tFuturet"future_set_result_unless_cancelledt ConditiontEventt SemaphoretBoundedSemaphoretLockt_TimeoutGarbageCollectorcB`s eZdZd„Zd„ZRS(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....') cC`stjƒ|_d|_dS(Ni(t collectionstdequet_waiterst _timeouts(tself((s,lib/python2.7/site-packages/tornado/locks.pyt__init__#scC`sM|jd7_|jdkrId|_tjd„|jDƒƒ|_ndS(Niidics`s!|]}|jƒs|VqdS(N(tdone(t.0tw((s,lib/python2.7/site-packages/tornado/locks.pys -s(RRRR(R((s,lib/python2.7/site-packages/tornado/locks.pyt_garbage_collect's  (t__name__t __module__t__doc__RR(((s,lib/python2.7/site-packages/tornado/locks.pyR s cB`sAeZdZd„Zd„Zdd„Zdd„Zd„ZRS(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:: from tornado import gen from tornado.ioloop import IOLoop from tornado.locks import Condition condition = Condition() async def waiter(): print("I'll wait right here") await condition.wait() print("I'm done waiting") async def notifier(): print("About to notify") condition.notify() print("Done notifying") async def runner(): # Wait for waiter() and notifier() in parallel await gen.multi([waiter(), notifier()]) IOLoop.current().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.current() # Wait up to 1 second for a notification. await condition.wait(timeout=io_loop.time() + 1) ...or a `datetime.timedelta` for a timeout relative to the current time:: # Wait up to 1 second. await condition.wait(timeout=datetime.timedelta(seconds=1)) The method returns False if there's no notification before the deadline. .. versionchanged:: 5.0 Previously, waiters could be notified synchronously from within `notify`. Now, the notification will always be received on the next iteration of the `.IOLoop`. cC`s)tt|ƒjƒtjjƒ|_dS(N(tsuperRRRtIOLooptcurrenttio_loop(R((s,lib/python2.7/site-packages/tornado/locks.pyRlscC`s>d|jjf}|jr6|dt|jƒ7}n|dS(Ns<%ss waiters[%s]t>(t __class__RRtlen(Rtresult((s,lib/python2.7/site-packages/tornado/locks.pyt__repr__ps c`srtƒ‰ˆjjˆƒ|rn‡‡fd†}tjjƒ‰ˆj||ƒ‰ˆj‡‡fd†ƒ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ƒstˆtƒnˆjƒdS(N(RRtFalseR((Rtwaiter(s,lib/python2.7/site-packages/tornado/locks.pyt on_timeouts c`s ˆjˆƒS(N(tremove_timeout(t_(Rttimeout_handle(s,lib/python2.7/site-packages/tornado/locks.pyt†s(RRtappendRRRt add_timeouttadd_done_callback(RttimeoutR&((RRR)R%s,lib/python2.7/site-packages/tornado/locks.pytwaitvs icC`ssg}xH|rP|jrP|jjƒ}|jƒs |d8}|j|ƒq q Wx|D]}t|tƒqXWdS(sWake ``n`` waiters.iN(RtpopleftRR+RtTrue(RtntwaitersR%((s,lib/python2.7/site-packages/tornado/locks.pytnotify‰s   cC`s|jt|jƒƒdS(sWake all waiters.N(R4R!R(R((s,lib/python2.7/site-packages/tornado/locks.pyt notify_all•sN( RRRRR#tNoneR/R4R5(((s,lib/python2.7/site-packages/tornado/locks.pyR0s :    cB`sGeZdZd„Zd„Zd„Zd„Zd„Zdd„Z RS(s½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:: from tornado import gen from tornado.ioloop import IOLoop from tornado.locks import Event event = Event() async def waiter(): print("Waiting for event") await event.wait() print("Not waiting this time") await event.wait() print("Done") async def setter(): print("About to set the event") event.set() async def runner(): await gen.multi([waiter(), setter()]) IOLoop.current().run_sync(runner) .. testoutput:: Waiting for event About to set the event Not waiting this time Done cC`st|_tƒ|_dS(N(R$t_valuetsetR(R((s,lib/python2.7/site-packages/tornado/locks.pyRÁs cC`s&d|jj|jƒrdndfS(Ns<%s %s>R8tclear(R Rtis_set(R((s,lib/python2.7/site-packages/tornado/locks.pyR#ÅscC`s|jS(s-Return ``True`` if the internal flag is true.(R7(R((s,lib/python2.7/site-packages/tornado/locks.pyR:ÉscC`sI|jsEt|_x0|jD]"}|jƒs|jdƒqqWndS(sƒSet the internal flag to ``True``. All waiters are awakened. Calling `.wait` once the flag is set will not block. N(R7R1RRt set_resultR6(Rtfut((s,lib/python2.7/site-packages/tornado/locks.pyR8Ís    cC`s t|_dS(skReset the internal flag to ``False``. Calls to `.wait` will block until `.set` is called. N(R$R7(R((s,lib/python2.7/site-packages/tornado/locks.pyR9Ùsc`s’tƒ‰ˆjr#ˆjdƒˆSˆjjˆƒˆj‡fd†ƒ|dkrYˆStj|ˆdt fƒ}|j‡fd†ƒ|SdS(sŒBlock until the internal flag is true. Returns a Future, which raises `tornado.util.TimeoutError` after a timeout. c`sˆjj|ƒS(N(Rtremove(R<(R(s,lib/python2.7/site-packages/tornado/locks.pyR*ëstquiet_exceptionsc`sˆjƒsˆjƒSdS(N(RtcancelR6(ttf(R<(s,lib/python2.7/site-packages/tornado/locks.pyR*ósN( RR7R;R6RtaddR-Rt with_timeoutR(RR.t timeout_fut((R<Rs,lib/python2.7/site-packages/tornado/locks.pyR/às    N( RRRRR#R:R8R9R6R/(((s,lib/python2.7/site-packages/tornado/locks.pyR šs&    t_ReleasingContextManagercB`s)eZdZd„Zd„Zd„ZRS(s³Releases a Lock or Semaphore at the end of a "with" statement. with (yield semaphore.acquire()): pass # Now semaphore.release() has been called. cC`s ||_dS(N(t_obj(Rtobj((s,lib/python2.7/site-packages/tornado/locks.pyRÿscC`sdS(N((R((s,lib/python2.7/site-packages/tornado/locks.pyt __enter__scC`s|jjƒdS(N(REtrelease(Rtexc_typetexc_valtexc_tb((s,lib/python2.7/site-packages/tornado/locks.pyt__exit__s(RRRRRGRL(((s,lib/python2.7/site-packages/tornado/locks.pyRD÷s  cB`skeZdZdd„Zd„Zd„Zd d„Zd„ZeZ e j d„ƒZ e j d„ƒZ RS( sS 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 from tornado.ioloop import IOLoop from tornado.concurrent import Future # Ensure reliable doctest output: resolve Futures one at a time. futures_q = deque([Future() for _ in range(3)]) async def simulator(futures): for f in futures: # simulate the asynchronous passage of time await gen.sleep(0) await gen.sleep(0) f.set_result(None) IOLoop.current().add_callback(simulator, list(futures_q)) def use_some_resource(): return futures_q.popleft() .. testcode:: semaphore from tornado import gen from tornado.ioloop import IOLoop from tornado.locks import Semaphore sem = Semaphore(2) async def worker(worker_id): await sem.acquire() try: print("Worker %d is working" % worker_id) await use_some_resource() finally: print("Worker %d is done" % worker_id) sem.release() async def runner(): # Join all workers. await gen.multi([worker(i) for i in range(3)]) IOLoop.current().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. The semaphore can be used as an async context manager:: async def worker(worker_id): async with sem: print("Worker %d is working" % worker_id) await use_some_resource() # Now the semaphore has been released. print("Worker %d is done" % worker_id) For compatibility with older versions of Python, `.acquire` is a context manager, so ``worker`` could also 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) .. versionchanged:: 4.3 Added ``async with`` support in Python 3.5. icC`s;tt|ƒjƒ|dkr.tdƒ‚n||_dS(Nis$semaphore initial value must be >= 0(RR Rt ValueErrorR7(Rtvalue((s,lib/python2.7/site-packages/tornado/locks.pyRhs cC`sztt|ƒjƒ}|jdkr*dndj|jƒ}|jrcdj|t|jƒƒ}ndj|dd!|ƒS(Nitlockedsunlocked,value:{0}s{0},waiters:{1}s <{0} [{1}]>iiÿÿÿÿ(RR R#R7tformatRR!(Rtrestextra((s,lib/python2.7/site-packages/tornado/locks.pyR#os   cC`sd|jd7_xN|jr_|jjƒ}|jƒs|jd8_|jt|ƒƒPqqWdS(s*Increment the counter and wake one waiter.iN(R7RR0RR;RD(RR%((s,lib/python2.7/site-packages/tornado/locks.pyRHws  c`s¦tƒ‰ˆjdkr=ˆjd8_ˆjtˆƒƒneˆjjˆƒ|r¢‡‡fd†}tjjƒ‰ˆj ||ƒ‰ˆj ‡‡fd†ƒ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. iic`s0ˆjƒs"ˆjtjƒƒnˆjƒdS(N(Rt set_exceptionRt TimeoutErrorR((RR%(s,lib/python2.7/site-packages/tornado/locks.pyR&•s c`s ˆjˆƒS(N(R'(R((RR)(s,lib/python2.7/site-packages/tornado/locks.pyR*œs( RR7R;RDRR+RRRR,R-(RR.R&((RRR)R%s,lib/python2.7/site-packages/tornado/locks.pytacquireˆs cC`stdƒ‚dS(NsPUse Semaphore like 'with (yield semaphore.acquire())', not like 'with semaphore'(t RuntimeError(R((s,lib/python2.7/site-packages/tornado/locks.pyRGŸscc`s|jƒVdS(N(RU(R((s,lib/python2.7/site-packages/tornado/locks.pyt __aenter__¦scC`s|jƒdS(N(RH(RttypRNttb((s,lib/python2.7/site-packages/tornado/locks.pyt __aexit__ªsN(RRRRR#RHR6RURGRLRt coroutineRWRZ(((s,lib/python2.7/site-packages/tornado/locks.pyR s^     cB`s#eZdZdd„Zd„ZRS(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. icC`s&tt|ƒjd|ƒ||_dS(NRN(RR Rt_initial_value(RRN((s,lib/python2.7/site-packages/tornado/locks.pyR·scC`s8|j|jkr!tdƒ‚ntt|ƒjƒdS(s*Increment the counter and wake one waiter.s!Semaphore released too many timesN(R7R\RMRR RH(R((s,lib/python2.7/site-packages/tornado/locks.pyRH»s(RRRRRH(((s,lib/python2.7/site-packages/tornado/locks.pyR ¯s cB`sheZdZd„Zd„Zdd„Zd„Zd„ZeZ e j d„ƒZ e j d„ƒZ RS( sÏ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`. A Lock can be used as an async context manager with the ``async with`` statement: >>> from tornado import locks >>> lock = locks.Lock() >>> >>> async def f(): ... async with lock: ... # Do something holding the lock. ... pass ... ... # Now the lock is released. For compatibility with older versions of Python, the `.acquire` method asynchronously returns a regular context manager: >>> async def f2(): ... with (yield lock.acquire()): ... # Do something holding the lock. ... pass ... ... # Now the lock is released. .. versionchanged:: 4.3 Added ``async with`` support in Python 3.5. cC`stddƒ|_dS(NRNi(R t_block(R((s,lib/python2.7/site-packages/tornado/locks.pyRæscC`sd|jj|jfS(Ns<%s _block=%s>(R RR](R((s,lib/python2.7/site-packages/tornado/locks.pyR#és cC`s|jj|ƒS(sˆAttempt to lock. Returns a Future. Returns a Future, which raises `tornado.util.TimeoutError` after a timeout. (R]RU(RR.((s,lib/python2.7/site-packages/tornado/locks.pyRUîscC`s5y|jjƒWntk r0tdƒ‚nXdS(sŠUnlock. The first coroutine in line waiting for `acquire` gets the lock. If not locked, raise a `RuntimeError`. srelease unlocked lockN(R]RHRMRV(R((s,lib/python2.7/site-packages/tornado/locks.pyRHös cC`stdƒ‚dS(Ns7Use Lock like 'with (yield lock)', not like 'with lock'(RV(R((s,lib/python2.7/site-packages/tornado/locks.pyRGscc`s|jƒVdS(N(RU(R((s,lib/python2.7/site-packages/tornado/locks.pyRWscC`s|jƒdS(N(RH(RRXRNRY((s,lib/python2.7/site-packages/tornado/locks.pyRZ sN(RRRRR#R6RURHRGRLRR[RWRZ(((s,lib/python2.7/site-packages/tornado/locks.pyR Âs#    (t __future__RRRRtconcurrent.futuresRttornadoRRttornado.concurrentRRt__all__tobjectR RR RDR R R (((s,lib/python2.7/site-packages/tornado/locks.pyts j]¦