# `pools` - Generic pools of resources

class eventlet.pools.Pool(min_size=0, max_size=4, order_as_stack=False, create=None)

  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 `functools.partial()`:

      from functools import partial
      http_pool = pools.Pool(create=partial(httplib2.Http, timeout=90))

  When subclassing, define only the `create()` method to implement the desired resource:

      class MyPool(pools.Pool):
          def create(self):
              return MyObject()

  If using 2.5 or greater, the `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 `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 `get()` to cooperatively yield until an item is `put()` in.

  create()

    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, `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 `get()` will result in a call to `create()`. If the first caller calls `put()` before some other caller calls `get()`, then the first item will be returned, and `create()` will not be called a second time.

  free()

    Return the number of free items in the pool. This corresponds to the number of `get()` calls needed to empty the pool.

  get()

    Return an item from the pool, when one is available. This may cause the calling greenthread to block.

  item()

    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

  put(item)

    Put an item back into the pool, when done. This may cause the putting greenthread to block.

  resize(new_size)

    Resize 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 `get()`/`put()` cycles will be necessary before the new maximum size truly matches the actual operation of the pool.

  waiting()

    Return the number of routines waiting for a pool item.

class eventlet.pools.TokenPool(min_size=0, max_size=4, order_as_stack=False, create=None)

  A 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.

  create()

    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, `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 `get()` will result in a call to `create()`. If the first caller calls `put()` before some other caller calls `get()`, then the first item will be returned, and `create()` will not be called a second time.