To focus the search input from anywhere on the page, press the 'S' key.
in-package search v0.1.0
External resource pools.
This module provides an abstraction for managing collections of resources. One example use case is for managing a pool of database connections, where instead of establishing a new connection each time you need one (which is expensive), you can keep a pool of opened connections and reuse ones that are free.
It also provides the capability of:
- specifying the maximum number of resources that the pool can manage simultaneously,
- checking whether a resource is still valid before/after use, and
- performing cleanup logic before dropping a resource.
The following example illustrates how it is used with an imaginary
let uri = "postgresql://localhost:5432" (* Create a database connection pool with max size of 10. *) let pool = Resource_pool.create 10 ~dispose:(fun connection -> Db.close connection |> Lwt.return) (fun () -> Db.connect uri |> Lwt.return) (* Use the pool in queries. *) let create_user name = Resource_pool.use pool (fun connection -> connection |> Db.insert "users" [("name", name)] |> Lwt.return )
Note that this is not intended to keep a pool of system threads. If you want to have such pool, consider using
val create : ?validate:('a -> bool Lwt.t) -> ?check:('a -> (bool -> unit) -> unit) -> ?dispose:('a -> unit Lwt.t) -> int -> (unit -> 'a Lwt.t) -> 'a t
create n ?check ?validate ?dispose f creates a new pool with at most
f is used to create a new pool element. Elements are created on demand and re-used until disposed of.
f may raise the exception
Resource_invalid to signal a failed resource creation. In this case
use will re-attempt to create the resource (according to
val set_max : 'a t -> int -> unit
set the maximum size of the pool
exception to be thrown by the function supplied to
use when a resource is no longer valid and therefore to be disposed of
use p f requests one free element of the pool
p and gives it to the function
f. The element is put back into the pool after the promise created by
In case the resource supplied to
f is no longer valid,
f can throw a
Resource_invalid exception in which case the resource is disposed of.
1) controls the number of resource creation attempts that are made in case the creation function raises the
1) controls the number of attempts that are made in case
f raises the
Resource_invalid exception. After each attempt the resource is disposed of. Be reminded to take into account any side-effects
f might have already trigged before raising the exception.
In the case that
p is exhausted and the maximum number of elements is reached,
use will wait until one becomes free.
clear p will clear all elements in
p, calling the
dispose function associated with
p on each of the cleared elements. Any elements from
p which are currently in use will be disposed of once they are released.
The next call to
use p after
clear p guarantees a freshly created pool element.
Disposals are performed sequentially in an undefined order.
val add : ?omit_max_check:bool -> 'a t -> 'a -> unit
add p c you can add an existing resource element
c to pool
p. This function may raise a
Resource_limit_exceeded exception. If
false), then this exception will not be raised. Instead the maximum number of resources might be exceeded and more than
p.max elements will be available to the user.