moonpool

// Here a connection is just its number; any type works.
let pool : @moonpool.Pool[Int] = @moonpool.Pool::new(
  limits=@moonpool.Limits::new(size=20),
)
let now = 0L
match pool.take(now, roll=0.42) {
  Ready(conn) => ignore(pool.give(conn, now))   // lend, then take it back
  Stale(conn) => ignore(conn)                   // too old: close it, ask again
  Make => pool.made(1, now)                     // open one; unmade(now) if that fails
  Wait => ()                                    // all in use: queue the caller
  Later(wait) => ignore(wait)                   // making is held back this long
  Shed => ()                                    // fail now: the backend or the host said no
}

#Six answers

#The four limits

#Nothing is lost

#The books

let counted : @moonpool.Pool[Int] = @moonpool.Pool::new(
  limits=@moonpool.Limits::new(size=8),
)
ignore(counted.take(0L))
counted.made(1, 0L)
ignore(counted.give(1, 100_000_000L))
ignore(counted.take(200_000_000L))
let books = counted.books()
assert_eq(books.live, 1)
assert_eq(books.loans, 2L)
assert_eq(books.reused, 1L)
// One was made for the asker; the other came out of idle.
assert_eq(books.made, 1L)

for loan in counted.loans(500_000_000L) {
  assert_eq(loan.item, 1)
  assert_eq(loan.held, @moondate.Span::new(millis=300L))
}

#Around the pool

#Conformance

• A broken resource. SQLAlchemy marks a discarded connection for replacement at the next borrow instead of taking it off its books, so what it hands out next, and how many it says are idle at that instant, are its own bookkeeping rather than the decision. The traces that drop one are therefore compared against node-generic-pool, which discards at once and agrees with this package; SQLAlchemy still runs the four plans, the broken-resource one among them, and agrees on those.
• A ceiling on idle resources. Neither reference has one, so it is covered by unit tests.

#One owner

#Install

moon add moonbitstack/moonpool

#See it run

moon run src/examples/sim

#Licence