Don't use a worker in pool.putconn() if not needed

If _reset is not set there is little work to do so the overhead of a
context switch is measurable and not necessary.

pool: fix off-by-one error in shrink log message

Add async pool stats

Add pool connection_class parameter

Make pool params keyword only in subclasses too

Add pool stats

Add reset callback to connection pool

Make sure that the pool config function leaves connections in idle state

Rename pool.wait_ready() to pool.wait()

Drop especially flaky async test dealing with del behaviour

Add AsyncConnectionPool.check()

Simpler, more approximative, more reliable pool max lifetime test

More tolerance in schedule timing tests

Add test for pool config

Don't throw an error on context exit if the connection is closed

Make the async pool unavailable on Python 3.6

Because of https://bugs.python.org/issue42600 or thereabout.

Don't use threads to manage the scheduler and workers of async tasks

Add an async scheduler

Drop get_running_loop call on async pool close

Add compat module for python versions compatibility

Add pool.check()

Set a timeout for the test run

retry flaky max lifetime test

Add Connection.broken

Add max_lifetime to pool connections

Add jitter method to pool

Use more of the pool context manager in the tests

Retry flaky tests a few times

Add pool context managers

Add pool.resize()

Make cleanup tests more reliable

Unfortunately there is some race condition on delete and for now just
using a timer.

In order to limit the problem don't actually run the StopWorker task but
bail out from the workers as soon as seen.

Fix Python 3.6 compatibility issues in async pool

Add async connection pool

Move non-blocking pool functionalities to a generic base class

Note that running maintenance threads is "non-blocking" and will be
thread-based in the async pool.

Add pool.wait_ready, drop connection_timeout on init

This way init should never block. Always fill the connection in
background but a client can decide if they want to wait for it to be
ready.

Split the pool package objects in modules

Move task implementations to the pool object

Make psycopg3.pool a package

Use the daemon param at constructor rather than the attribute

Use the connections in the pool uniformly

I feel this is a better use than using some more than other (e.g. in
term of bloat of the connections associated with the resources) and
gives a more predictable performance of the connection (there won't be
some cold, some hot).

Now there aren't really "unused connections" to single out in order to
shrink the pool. So keep a tally of the number of connections unused and
use a worker thread to close some if there are above minconn unused in a
period.

Change state in critical section on pool.close()

Nothing bad should happen, because what maintains the state respect the
_closed state. However because the logic is complex make it more
defensive.

Make any pool task schedulable

Added interface to the pool to schedule a task in the future.

Don't lose pool connections giving them to a clients already timed out

Allow proxy tests to fail on Travis

Don't know why it fails, it requires interactive investigation there.
Make sure tests can run connecting on TCP socket and avoid SSH in the
proxy anyway. Not that any of this worked...

Wait worker thread to stop on pool close

Don't print warning gc'ing a pool in incomplete state

pool.close() called on del, idemptotent

Add separate setup_timeout param for pool

Allow 0 too, which would fill the pool in background.

Drop _sec suffix from pool timeouts

Python is consistent enough to use seconds everywhere timeouts are
involved.

Add pool reconnection retry

Don't try to rollback on exit if the connection is bad

Use a weak reference to avoid loops between pool and maintenance tasks

Add scheduler class

To be used in the connection pool to implement reconnection with
backoff, maybe periodic tasks.

Add test for pool kwargs

Default number of pool workers bumped to 3

Shrink the pool when connections have been idle long enough

Pool behaviour on start changed: block on __init__ until minconn
connections have been obtained or raise PoolTimeout if timeout_sec have
passed. Not doing so makes complicated to understand, when a connection
is requested, if it's done during initialisation, and avoid an unneeded
grow request.

Don't waste a worker thread adding a connection to the pool

Force pool num_workers to be > 0

it might work with num_workers = 0, however it's not trivial, there is
some deadlock to avoid at creation time.

Allow the pool to grow

Make the pool maintenance tasks base class abstract

Delete an eventual task-pool loop in StopWorker too

Add pool docstrings

Add connection pool close()

When the pool is closed, raise an exception in the thread of the clients
already waiting and refuse new requests. Let the current request finish
anyway.

Make sure the pool can be deleted with no warning

Make sure to delete reference loops between the pool and the maintenance
tasks after they have run.

Do not raise a warning if a connection in a pool is deleted without
being closed as this is a normal condition (imagining a pool being
created as a global object).

Add pool context test

Awake the pool client outside the critical section

Reset the connection status returning it to the pool

Add basic pool functionality test for queuing and timeout

Display the name in the connection pool repr

Add ConnectionPool class sketch

It has a pool of connections alright, workers, clients waiting list.

Only minconn implemented, no maintenance thread etc. It's a start.

@logilab is backing psycopg3!

Merci beaucoup!

Welcoming @dalibo as backer

Vive la France!

Fix concurrency test

It was blocking because the committer was a too busy loop never yielding
to the other worker.

Use gather instead of wait in tests to be coro friendly

Bump mypy version

ci: get token to rebuild docs from secrets

Merge branch 'ci-gh-actions'

Yaml lint

Run leak tests with both text and binary output

At the moment the output text is actually skipped but it will run once
text input is no more xfailed.

Fix binary argument of conn.cursor() in tests

Argument 'binary' of connection.cursor() should be a bool.
This follows up on 467d20bd0315a62b4c7377d8a0b170ece08ef99c (change from
'format' to 'binary').

ci: consistent uppercase in steps titles

ci: Test with Python 3.9 and PostgreSQL 13

Test different combination of Python and Postgres in the different
implementation to cover more cases.

ci: Allow lint and test on any branch

ci: colour tests output

tox: use the github action "python" value as toxenv name

ci; Use PG* env vars to define the connection string

ci: Fix test dsn

The github runner /etc/host file is pretty broken and localhost resolves
to ipv6, so use 127.0.0.1 to connect.

ci: sort out connection to postgresql service

ci: split tests in one job for each implementation

To simplify the matrix

ci: move tests to gh actions

ci: move docs building to gh actions

ci: move lint task to gh actions

Update script to trigger docs rebuild to use travis-ci.com

Retry server-side cursor tests on del

Warnings seem unreliably to receive. Also print any eventual unexpected
warning: pytest doesn't do it automatically.

Add fixture to help retrying flaky tests

Tried to use a couple of pytest plugins for retrying but they don't work
well with asyncio.

Make the DBAPI errors appear defined in the psycopg3 module

Drop psycopg3.pq.PQerror

Use an OperationalError instead (of which PQerror was a subclass), which
is better documented.

Add doc example about how to detect a disconnection

Add Connection.fileno()

Fix return error without exception on PQsocket call of broken connection

Still some weirdness here around: the method raises an exception on my
box (both with unix and tcp socket) but it seems to raise still a valid
number on certain databases on Travis. Make sure, in the test, at least
that it is a reasonable value.