3 Z_]@shddlmZddlZddlmZddlmZddgZGdddeZ Gdd d eZ Gd dde Z dS) )print_functionN)contextmanager)queuePool TokenPoolc@sVeZdZdZdddZdd Zed d Zd d ZddZ ddZ ddZ ddZ dS)ra  Pool class implements resource limitation and construction. There are two ways of using Pool: passing a `create` argument or subclassing. In either case you must provide a way to create the resource. When using `create` argument, pass a function with no arguments:: http_pool = pools.Pool(create=httplib2.Http) If you need to pass arguments, build a nullary function with either `lambda` expression:: http_pool = pools.Pool(create=lambda: httplib2.Http(timeout=90)) or :func:`functools.partial`:: from functools import partial http_pool = pools.Pool(create=partial(httplib2.Http, timeout=90)) When subclassing, define only the :meth:`create` method to implement the desired resource:: class MyPool(pools.Pool): def create(self): return MyObject() If using 2.5 or greater, the :meth:`item` method acts as a context manager; that's the best way to use it:: with mypool.item() as thing: thing.dostuff() The maximum size of the pool can be modified at runtime via the :meth:`resize` method. Specifying a non-zero *min-size* argument pre-populates the pool with *min_size* items. *max-size* sets a hard limit to the size of the pool -- it cannot contain any more items than *max_size*, and if there are already *max_size* items 'checked out' of the pool, the pool will cause any greenthread calling :meth:`get` to cooperatively yield until an item is :meth:`put` in. rFNcCsp||_||_||_d|_tjd|_tj|_ |dk r<||_ x.t |D]"}|jd7_|j j |j qFWdS)a*order_as_stack* governs the ordering of the items in the free pool. If ``False`` (the default), the free items collection (of items that were created and were put back in the pool) acts as a round-robin, giving each item approximately equal utilization. If ``True``, the free pool acts as a FILO stack, which preferentially re-uses items that have most recently been used. rN) min_sizemax_sizeorder_as_stack current_sizerZ LightQueuechannel collectionsdeque free_itemscreaterangeappend)selfr r r rxr2/tmp/pip-build-yz_zf6az/eventlet/eventlet/pools.py__init__:s  z Pool.__init__c Csp|jr|jjS|jd7_|j|jkrXy |j}Wn|jd8_YnX|S|jd8_|jjS)zwReturn an item from the pool, when one is available. This may cause the calling greenthread to block. r)rpopleftr r rr get)rcreatedrrrrOs   zPool.getc cs$|j}z |VWd|j|XdS)a$ Get an object out of the pool, for use with with statement. >>> from eventlet import pools >>> pool = pools.TokenPool(max_size=4) >>> with pool.item() as obj: ... print("got token") ... got token >>> pool.free() 4 N)rput)robjrrritem`s  z Pool.itemc Csv|j|jkr|jd8_dS|jrRy|jj|dddStjk rPYnX|jrf|jj |n |jj |dS)zmPut an item back into the pool, when done. This may cause the putting greenthread to block. rNF)block) r r waitingr rrFullr r appendleftr)rrrrrrss zPool.putcCs ||_dS)ayResize the pool to *new_size*. Adjusting this number does not affect existing items checked out of the pool, nor on any greenthreads who are waiting for an item to free up. Some indeterminate number of :meth:`get`/:meth:`put` cycles will be necessary before the new maximum size truly matches the actual operation of the pool. N)r )rZnew_sizerrrresizes z Pool.resizecCst|j|j|jS)zReturn the number of free items in the pool. This corresponds to the number of :meth:`get` calls needed to empty the pool. )lenrr r )rrrrfreesz Pool.freecCstd|jj|jjS)z?Return the number of routines waiting for a pool item. r)maxr ZgettingZputting)rrrrr sz Pool.waitingcCs tddS)a%Generate a new pool item. In order for the pool to function, either this method must be overriden in a subclass or the pool must be constructed with the `create` argument. It accepts no arguments and returns a single instance of whatever thing the pool is supposed to contain. In general, :meth:`create` is called whenever the pool exceeds its previous high-water mark of concurrently-checked-out-items. In other words, in a new pool with *min_size* of 0, the very first call to :meth:`get` will result in a call to :meth:`create`. If the first caller calls :meth:`put` before some other caller calls :meth:`get`, then the first item will be returned, and :meth:`create` will not be called a second time. zImplement in subclassN)NotImplementedError)rrrrrsz Pool.create)rrFN) __name__ __module__ __qualname____doc__rrrrrr#r%r rrrrrr s,   c@s eZdZdS)TokenN)r(r)r*rrrrr,sr,c@seZdZdZddZdS)rzA pool which gives out tokens (opaque unique objects), which indicate that the coroutine which holds the token has a right to consume some limited resource. cCstS)N)r,)rrrrrszTokenPool.createN)r(r)r*r+rrrrrrs) __future__rr contextlibrZeventletr__all__objectrr,rrrrrs   $