fix borrowing errors

Started on md5 auth.
Left to figure out: Whats the right format to store user:pw in userlist? hashmap errors? actually do hash:x comparison
2026-03-23 09:26:30 +00:00 · 2022-03-04 12:24:53 -08:00 · 2022-03-04 12:11:17 -07:00
54 changed files with 1793 additions and 7092 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -9,40 +9,16 @@ jobs:
    # Specify the execution environment. You can specify an image from Dockerhub or use one of our Convenience Images from CircleCI's Developer Hub.
    # See: https://circleci.com/docs/2.0/configuration-reference/#docker-machine-macos-windows-executor
    docker:
-      - image: levkk/pgcat-ci:latest
+      - image: cimg/rust:1.58.1
        environment:
          RUST_LOG: info
-          RUSTFLAGS: "-C instrument-coverage"
-          LLVM_PROFILE_FILE: "pgcat-%m.profraw"
-      - image: postgres:14
-        command: ["postgres", "-p", "5432", "-c", "shared_preload_libraries=pg_stat_statements"]
+      - image: cimg/postgres:14.0
+        auth:
+          username: mydockerhub-user
+          password: $DOCKERHUB_PASSWORD
        environment:
          POSTGRES_USER: postgres
          POSTGRES_DB: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_HOST_AUTH_METHOD: scram-sha-256
-      - image: postgres:14
-        command: ["postgres", "-p", "7432", "-c", "shared_preload_libraries=pg_stat_statements"]
-        environment:
-          POSTGRES_USER: postgres
-          POSTGRES_DB: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_HOST_AUTH_METHOD: scram-sha-256
-      - image: postgres:14
-        command: ["postgres", "-p", "8432", "-c", "shared_preload_libraries=pg_stat_statements"]
-        environment:
-          POSTGRES_USER: postgres
-          POSTGRES_DB: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_HOST_AUTH_METHOD: scram-sha-256
-      - image: postgres:14
-        command: ["postgres", "-p", "9432", "-c", "shared_preload_libraries=pg_stat_statements"]
-        environment:
-          POSTGRES_USER: postgres
-          POSTGRES_DB: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_HOST_AUTH_METHOD: scram-sha-256
-
    # Add steps to the job
    # See: https://circleci.com/docs/2.0/configuration-reference/#steps
    steps:
@@ -54,19 +30,16 @@ jobs:
          command: "cargo fmt --check"
      - run:
          name: "Install dependencies"
-          command: "sudo apt-get update && sudo apt-get install -y psmisc postgresql-contrib-12 postgresql-client-12 ruby ruby-dev libpq-dev python3 python3-pip lcov llvm-11 && sudo apt-get upgrade curl"
+          command: "sudo apt-get update && sudo apt-get install -y psmisc postgresql-contrib-12 postgresql-client-12 ruby ruby-dev libpq-dev"
      - run:
-          name: "Install rust tools"
-          command: "cargo install cargo-binutils rustfilt && rustup component add llvm-tools-preview"
-      - run:
-          name: "Build"
+          name: "Build" 
          command: "cargo build"
      - run:
-          name: "Tests"
-          command: "cargo test && bash .circleci/run_tests.sh && .circleci/generate_coverage.sh"
-      - store_artifacts:
-          path: /tmp/cov
-          destination: coverage-data
+          name: "Test"
+          command: "cargo test"
+      - run:
+          name: "Test end-to-end"
+          command: "bash .circleci/run_tests.sh"
      - save_cache:
          key: cargo-lock-2-{{ checksum "Cargo.lock" }}
          paths:
--- a/.circleci/generate_coverage.sh
+++ b/.circleci/generate_coverage.sh
@@ -1,7 +0,0 @@
-#!/bin/bash
-
-rust-profdata merge -sparse pgcat-*.profraw -o pgcat.profdata
-
-rust-cov export -ignore-filename-regex="rustc|registry" -Xdemangler=rustfilt -instr-profile=pgcat.profdata --object ./target/debug/pgcat --format lcov > ./lcov.info
-
-genhtml lcov.info --output-directory /tmp/cov --prefix $(pwd)
--- a/.circleci/pgcat.toml
+++ b/.circleci/pgcat.toml
@@ -5,55 +5,78 @@
 #
 # General pooler settings
 [general]
+
 # What IP to run on, 0.0.0.0 means accessible from everywhere.
 host = "0.0.0.0"

 # Port to run on, same as PgBouncer used in this example.
 port = 6432

-# Whether to enable prometheus exporter or not.
-enable_prometheus_exporter = true
+# How many connections to allocate per server.
+pool_size = 15

-# Port at which prometheus exporter listens on.
-prometheus_exporter_port = 9930
-
-# How long to wait before aborting a server connection (ms).
-connect_timeout = 100
-
-# How much time to give the health check query to return with a result (ms).
-healthcheck_timeout = 100
-
-# How long to keep connection available for immediate re-use, without running a healthcheck query on it
-healthcheck_delay = 30000
-
-# How much time to give clients during shutdown before forcibly killing client connections (ms).
-shutdown_timeout = 5000
-
-# For how long to ban a server if it fails a health check (seconds).
-ban_time = 60 # Seconds
-
-# Reload config automatically if it changes.
-autoreload = true
-
-# TLS
-tls_certificate = ".circleci/server.cert"
-tls_private_key = ".circleci/server.key"
-
-# Credentials to access the virtual administrative database (pgbouncer or pgcat)
-# Connecting to that database allows running commands like `SHOW POOLS`, `SHOW DATABASES`, etc..
-admin_username = "admin_user"
-admin_password = "admin_pass"
-
-# pool
-# configs are structured as pool.<pool_name>
-# the pool_name is what clients use as database name when connecting
-# For the example below a client can connect using "postgres://sharding_user:sharding_user@pgcat_host:pgcat_port/sharded_db"
-[pools.sharded_db]
 # Pool mode (see PgBouncer docs for more).
 # session: one server connection per connected client
 # transaction: one server connection per client transaction
 pool_mode = "transaction"

+# How long to wait before aborting a server connection (ms).
+connect_timeout = 100
+
+# How much time to give `SELECT 1` health check query to return with a result (ms).
+healthcheck_timeout = 100
+
+# For how long to ban a server if it fails a health check (seconds).
+ban_time = 60 # Seconds
+
+# Stats will be sent here
+statsd_address = "127.0.0.1:8125"
+
+#
+# User to use for authentication against the server.
+[user]
+name = "sharding_user"
+password = "sharding_user"
+
+
+#
+# Shards in the cluster
+[shards]
+
+# Shard 0
+[shards.0]
+
+# [ host, port, role ]
+servers = [
+    [ "127.0.0.1", 5432, "primary" ],
+    [ "localhost", 5433, "replica" ],
+    # [ "127.0.1.1", 5432, "replica" ],
+]
+# Database name (e.g. "postgres")
+database = "shard0"
+
+[shards.1]
+# [ host, port, role ]
+servers = [
+    [ "127.0.0.1", 5432, "primary" ],
+    [ "localhost", 5433, "replica" ],
+    # [ "127.0.1.1", 5432, "replica" ],
+]
+database = "shard1"
+
+[shards.2]
+# [ host, port, role ]
+servers = [
+    [ "127.0.0.1", 5432, "primary" ],
+    [ "localhost", 5433, "replica" ],
+    # [ "127.0.1.1", 5432, "replica" ],
+]
+database = "shard2"
+
+
+# Settings for our query routing layer.
+[query_router]
+
 # If the client doesn't specify, route traffic to
 # this role by default.
 #
@@ -62,11 +85,12 @@ pool_mode = "transaction"
 # primary: all queries go to the primary unless otherwise specified.
 default_role = "any"

+
 # Query parser. If enabled, we'll attempt to parse
 # every incoming query to determine if it's a read or a write.
 # If it's a read query, we'll direct it to a replica. Otherwise, if it's a write,
 # we'll direct it to the primary.
-query_parser_enabled = true
+query_parser_enabled = false

 # If the query parser is enabled and this setting is enabled, the primary will be part of the pool of databases used for
 # load balancing of read queries. Otherwise, the primary will only be used for write
@@ -82,64 +106,3 @@ primary_reads_enabled = true
 # sha1: A hashing function based on SHA1
 #
 sharding_function = "pg_bigint_hash"
-
-# Credentials for users that may connect to this cluster
-[pools.sharded_db.users.0]
-username = "sharding_user"
-password = "sharding_user"
-# Maximum number of server connections that can be established for this user
-# The maximum number of connection from a single Pgcat process to any database in the cluster
-# is the sum of pool_size across all users.
-pool_size = 9
-statement_timeout = 0
-
-[pools.sharded_db.users.1]
-username = "other_user"
-password = "other_user"
-pool_size = 21
-statement_timeout = 30000
-
-# Shard 0
-[pools.sharded_db.shards.0]
-# [ host, port, role ]
-servers = [
-    [ "127.0.0.1", 5432, "primary" ],
-    [ "localhost", 5432, "replica" ]
-]
-# Database name (e.g. "postgres")
-database = "shard0"
-
-[pools.sharded_db.shards.1]
-servers = [
-    [ "127.0.0.1", 5432, "primary" ],
-    [ "localhost", 5432, "replica" ],
-]
-database = "shard1"
-
-[pools.sharded_db.shards.2]
-servers = [
-    [ "127.0.0.1", 5432, "primary" ],
-    [ "localhost", 5432, "replica" ],
-]
-database = "shard2"
-
-
-[pools.simple_db]
-pool_mode = "session"
-default_role = "primary"
-query_parser_enabled = true
-primary_reads_enabled = true
-sharding_function = "pg_bigint_hash"
-
-[pools.simple_db.users.0]
-username = "simple_user"
-password = "simple_user"
-pool_size = 5
-statement_timeout = 30000
-
-[pools.simple_db.shards.0]
-servers = [
-    [ "127.0.0.1", 5432, "primary" ],
-    [ "localhost", 5432, "replica" ]
-]
-database = "some_db"
--- a/.circleci/run_tests.sh
+++ b/.circleci/run_tests.sh
@@ -3,9 +3,6 @@
 set -e
 set -o xtrace

-# non-zero exit code if we provide bad configs
-(! ./target/debug/pgcat "fake_configs"  2>/dev/null)
-
 # Start PgCat with a particular log level
 # for inspection.
 function start_pgcat() {
@@ -15,21 +12,14 @@ function start_pgcat() {
 }

 # Setup the database with shards and user
-PGPASSWORD=postgres psql -e -h 127.0.0.1 -p 5432 -U postgres -f tests/sharding/query_routing_setup.sql
-PGPASSWORD=postgres psql -e -h 127.0.0.1 -p 7432 -U postgres -f tests/sharding/query_routing_setup.sql
-PGPASSWORD=postgres psql -e -h 127.0.0.1 -p 8432 -U postgres -f tests/sharding/query_routing_setup.sql
-PGPASSWORD=postgres psql -e -h 127.0.0.1 -p 9432 -U postgres -f tests/sharding/query_routing_setup.sql
-
-PGPASSWORD=sharding_user pgbench -h 127.0.0.1 -U sharding_user shard0 -i
-PGPASSWORD=sharding_user pgbench -h 127.0.0.1 -U sharding_user shard1 -i
-PGPASSWORD=sharding_user pgbench -h 127.0.0.1 -U sharding_user shard2 -i
+psql -e -h 127.0.0.1 -p 5432 -U postgres -f tests/sharding/query_routing_setup.sql

 # Install Toxiproxy to simulate a downed/slow database
-wget -O toxiproxy-2.4.0.deb https://github.com/Shopify/toxiproxy/releases/download/v2.4.0/toxiproxy_2.4.0_linux_$(dpkg --print-architecture).deb
-sudo dpkg -i toxiproxy-2.4.0.deb
+wget -O toxiproxy-2.1.4.deb https://github.com/Shopify/toxiproxy/releases/download/v2.1.4/toxiproxy_2.1.4_amd64.deb
+sudo dpkg -i toxiproxy-2.1.4.deb

 # Start Toxiproxy
-LOG_LEVEL=error toxiproxy-server &
+toxiproxy-server &
 sleep 1

 # Create a database at port 5433, forward it to Postgres
@@ -37,94 +27,56 @@ toxiproxy-cli create -l 127.0.0.1:5433 -u 127.0.0.1:5432 postgres_replica

 start_pgcat "info"

-# Check that prometheus is running
-curl --fail localhost:9930/metrics
-
-export PGPASSWORD=sharding_user
-export PGDATABASE=sharded_db
-
 # pgbench test
-pgbench -U sharding_user -i -h 127.0.0.1 -p 6432
-pgbench -U sharding_user -h 127.0.0.1 -p 6432 -t 500 -c 2 --protocol simple -f tests/pgbench/simple.sql
-pgbench -U sharding_user -h 127.0.0.1 -p 6432 -t 500 -c 2 --protocol extended
+pgbench -i -h 127.0.0.1 -p 6432 && \
+    pgbench -h 127.0.0.1 -p 6432 -t 500 -c 2 --protocol simple && \
+    pgbench -h 127.0.0.1 -p 6432 -t 500 -c 2 --protocol extended

 # COPY TO STDOUT test
-psql -U sharding_user -h 127.0.0.1 -p 6432 -c 'COPY (SELECT * FROM pgbench_accounts LIMIT 15) TO STDOUT;' > /dev/null
+psql -h 127.0.0.1 -p 6432 -c 'COPY (SELECT * FROM pgbench_accounts LIMIT 15) TO STDOUT;' > /dev/null

 # Query cancellation test
-(psql -U sharding_user -h 127.0.0.1 -p 6432 -c 'SELECT pg_sleep(50)' || true) &
-sleep 1
-killall psql -s SIGINT
-
-# Reload pool (closing unused server connections)
-PGPASSWORD=admin_pass psql -U admin_user -h 127.0.0.1 -p 6432 -d pgbouncer -c 'RELOAD'
-
-(psql -U sharding_user -h 127.0.0.1 -p 6432 -c 'SELECT pg_sleep(50)' || true) &
-sleep 1
+(psql -h 127.0.0.1 -p 6432 -c 'SELECT pg_sleep(5)' || true) &
 killall psql -s SIGINT

 # Sharding insert
-psql -U sharding_user -e -h 127.0.0.1 -p 6432 -f tests/sharding/query_routing_test_insert.sql
+psql -e -h 127.0.0.1 -p 6432 -f tests/sharding/query_routing_test_insert.sql

 # Sharding select
-psql -U sharding_user -e -h 127.0.0.1 -p 6432 -f tests/sharding/query_routing_test_select.sql > /dev/null
+psql -e -h 127.0.0.1 -p 6432 -f tests/sharding/query_routing_test_select.sql > /dev/null

 # Replica/primary selection & more sharding tests
-psql -U sharding_user -e -h 127.0.0.1 -p 6432 -f tests/sharding/query_routing_test_primary_replica.sql > /dev/null
-
-# Statement timeout tests
-sed -i 's/statement_timeout = 0/statement_timeout = 100/' .circleci/pgcat.toml
-kill -SIGHUP $(pgrep pgcat) # Reload config
-sleep 0.2
-
-# This should timeout
-(! psql -U sharding_user -e -h 127.0.0.1 -p 6432 -c 'select pg_sleep(0.5)')
-
-# Disable statement timeout
-sed -i 's/statement_timeout = 100/statement_timeout = 0/' .circleci/pgcat.toml
-kill -SIGHUP $(pgrep pgcat) # Reload config again
+psql -e -h 127.0.0.1 -p 6432 -f tests/sharding/query_routing_test_primary_replica.sql > /dev/null

 #
 # ActiveRecord tests
 #
-cd tests/ruby
-sudo gem install bundler
-bundle install
-bundle exec ruby tests.rb || exit 1
-bundle exec rspec *_spec.rb || exit 1
+cd tests/ruby && \
+    sudo gem install bundler && \
+    bundle install && \
+    ruby tests.rb && \
 cd ../..

-#
-# Python tests
-# These tests will start and stop the pgcat server so it will need to be restarted after the tests
-#
-pip3 install -r tests/python/requirements.txt
-python3 tests/python/tests.py || exit 1
-
-start_pgcat "info"
-
 # Admin tests
-export PGPASSWORD=admin_pass
-psql -U admin_user -e -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW STATS' > /dev/null
-psql -U admin_user -h 127.0.0.1 -p 6432 -d pgbouncer -c 'RELOAD' > /dev/null
-psql -U admin_user -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW CONFIG' > /dev/null
-psql -U admin_user -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW DATABASES' > /dev/null
-psql -U admin_user -h 127.0.0.1 -p 6432 -d pgcat -c 'SHOW LISTS' > /dev/null
-psql -U admin_user -h 127.0.0.1 -p 6432 -d pgcat -c 'SHOW POOLS' > /dev/null
-psql -U admin_user -h 127.0.0.1 -p 6432 -d pgcat -c 'SHOW VERSION' > /dev/null
-psql -U admin_user -h 127.0.0.1 -p 6432 -d pgbouncer -c "SET client_encoding TO 'utf8'" > /dev/null # will ignore
-(! psql -U admin_user -e -h 127.0.0.1 -p 6432 -d random_db -c 'SHOW STATS' > /dev/null)
-export PGPASSWORD=sharding_user
+psql -e -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW STATS' > /dev/null
+psql -h 127.0.0.1 -p 6432 -d pgbouncer -c 'RELOAD' > /dev/null
+psql -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW CONFIG' > /dev/null
+psql -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW DATABASES' > /dev/null
+psql -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW LISTS' > /dev/null
+psql -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW POOLS' > /dev/null
+psql -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW VERSION' > /dev/null
+psql -h 127.0.0.1 -p 6432 -d pgbouncer -c "SET client_encoding TO 'utf8'" > /dev/null # will ignore
+(! psql -e -h 127.0.0.1 -p 6432 -d random_db -c 'SHOW STATS' > /dev/null)

 # Start PgCat in debug to demonstrate failover better
-start_pgcat "trace"
+start_pgcat "debug"

 # Add latency to the replica at port 5433 slightly above the healthcheck timeout
 toxiproxy-cli toxic add -t latency -a latency=300 postgres_replica
 sleep 1

 # Note the failover in the logs
-timeout 5 psql -U sharding_user -e -h 127.0.0.1 -p 6432 <<-EOF
+timeout 5 psql -e -h 127.0.0.1 -p 6432 <<-EOF
 SELECT 1;
 SELECT 1;
 SELECT 1;
@@ -136,18 +88,13 @@ toxiproxy-cli toxic remove --toxicName latency_downstream postgres_replica
 start_pgcat "info"

 # Test session mode (and config reload)
-sed -i '0,/simple_db/s/pool_mode = "transaction"/pool_mode = "session"/' .circleci/pgcat.toml
+sed -i 's/pool_mode = "transaction"/pool_mode = "session"/' pgcat.toml

 # Reload config test
 kill -SIGHUP $(pgrep pgcat)

-# Revert settings after reload. Makes test runs idempotent
-sed -i '0,/simple_db/s/pool_mode = "session"/pool_mode = "transaction"/' .circleci/pgcat.toml
-
-sleep 1
-
 # Prepared statements that will only work in session mode
-pgbench -U sharding_user -h 127.0.0.1 -p 6432 -t 500 -c 2 --protocol prepared
+pgbench -h 127.0.0.1 -p 6432 -t 500 -c 2 --protocol prepared

 # Attempt clean shut down
 killall pgcat -s SIGINT
--- a/.circleci/server.cert
+++ b/.circleci/server.cert
@@ -1,21 +0,0 @@
-----BEGIN CERTIFICATE-----
-MIIDazCCAlOgAwIBAgIUChIvUGFJGJe5EDch32rchqoxER0wDQYJKoZIhvcNAQEL
-BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
-GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMjA2MjcyMjI2MDZaFw0yMjA3
-MjcyMjI2MDZaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
-HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB
-AQUAA4IBDwAwggEKAoIBAQDdTwrBzV1v79faVckFvIn/9V4fypYs4vDi3X+h3wGn
-AjEh6mmizlKCwSwAam07D9Q5zKiXFrzNJqzSioOv5zsOAvObwrnzbtKSwfs3aP5g
-eEh2clHCZYx9p06WszPcgSB5nTz1NeY4XAwvGn3A+SVCLyPMTNwnem48+ONh2F9u
-FHtSuIsEVvTjMlH09O7LjwJlODxy3HNv2JHYM5Hx9tzc+NVYdERPtaVcX8ycw1Eh
-9hgGSgfaNM52/JfRMIDhENrsn0S1omRUtcJe72loreiwrECUOLAnAfp9Xqc+rMPP
-aLA6ElzmYef1+ZEC0p6isCHPhxY5ESVhKYhE9nQvksjnAgMBAAGjUzBRMB0GA1Ud
-DgQWBBQLDtzexqjx7xPtUZuZB/angU9oSDAfBgNVHSMEGDAWgBQLDtzexqjx7xPt
-UZuZB/angU9oSDAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQC/
-mxY/a/WeLENVj2Gg9EUH0CKzfqeTey1mb6YfPGxzrD7oq1m0Vn2MmTbjZrJgh/Ob
-QckO3ElF4kC9+6XP+iDPmabGpjeLgllBboT5l2aqnD1syMrf61WPLzgRzRfplYGy
-cjBQDDKPu8Lu0QRMWU28tHYN0bMxJoCuXysGGX5WsuFnKCA6f/V+nycJJXxJH3eB
-eLjTueD9/RE3OXhi6m8A29Q1E9AE5EF4uRxYXrr91BmYnk4aFvSmBxhUEzE12eSN
-lHB/uSc0+Dp+UVmVr6wW8AQfd16UBA0BUf3kSW3aSvirYPYH0rXiOOpEJgOwOMnR
-f5+XAbN1Y+3OsFz/ZmP9
-----END CERTIFICATE-----
--- a/.circleci/server.key
+++ b/.circleci/server.key
@@ -1,28 +0,0 @@
-----BEGIN RSA PRIVATE KEY-----
-MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDdTwrBzV1v79fa
-VckFvIn/9V4fypYs4vDi3X+h3wGnAjEh6mmizlKCwSwAam07D9Q5zKiXFrzNJqzS
-ioOv5zsOAvObwrnzbtKSwfs3aP5geEh2clHCZYx9p06WszPcgSB5nTz1NeY4XAwv
-Gn3A+SVCLyPMTNwnem48+ONh2F9uFHtSuIsEVvTjMlH09O7LjwJlODxy3HNv2JHY
-M5Hx9tzc+NVYdERPtaVcX8ycw1Eh9hgGSgfaNM52/JfRMIDhENrsn0S1omRUtcJe
-72loreiwrECUOLAnAfp9Xqc+rMPPaLA6ElzmYef1+ZEC0p6isCHPhxY5ESVhKYhE
-9nQvksjnAgMBAAECggEAbnvddO9frFhivJ+DIhgEFQKcIOb0nigV9kx6QYehvYy8
-lp/+aMb0Lk7d9r8rFQdL/icMK5GwZALg2KNKJvEbbF1Q3PwT9VHoUlgBYKJMDEFA
-e9GKu7ASuVBjTZzdUUItwkkbe5eS/aQGeSWSjlpTnX0HNCFS72qRymK+scRhsAQf
-ZoHyZHDslkvPR3Pos+sndWBYCDHag5/KoPhsMt1+5S9NQcOUHx9Ac0gLHjau3N+P
-0FhODHFFGnnpyQvLvj6u3ZOR34ladMgoBglE0O3vPFhckn92EK4teeTWOsUMotiz
-qM3QIJTOJjtiY6VDGY93bIa4pFvt7Zi4vIerenKt0QKBgQD/UMFqfevTAMrk10AC
-bOa4+cM07ORY4ZwVj5ILhZn+8crDEEtBsUyuEU2FTINtnoEq1yGc/IXpsyS1BHjL
-L1xSml5LN3jInbi8z5XQfY5Sj3VOMtwY6yD20jcdeDC44rz3nStXdkcMWxbTMapx
-iOPsap5ciUKOMS7LyMidPEG/LQKBgQDd5vHgrLN0FBIIm+vZg6MEm4QyobstVp4l
-7V/GZsdL+M8AQv1Rx+5wSUSWKomOIv5lglis7f6g0c9O7Qkr78/wzoyoKC2RRqPp
-I90GjY2Iv22N4GIkRrDAgMZbkTitzIB6tbXEVeLAOh3frFJ8IwauRCOiXIjrZdJ4
-FvV86+nU4wKBgQDdWTP2kWkMrBk7QOp7r9Jv+AmnLuHhtOdPQgOJ/bA++X2ik9PL
-Bl3GY7XjpSwks1CkxZKcucmXjPp7/X6EGXFfI/owF82dkDADca0e7lufdERtIWb0
-K5WOpz2lTPhgsiLGQfq7fw2lxqsJOnvcpqOD6gOVkmKjSDyb7F0RBJazmQKBgQDD
-a8PQTcesjpBjLI3EfX1vbVY7ENu6zfFxDV+vZoxVh8UlQdm90AlYse3JIaUKnB7W
-Xrihcucv0hZ0N6RAIW5LcFvHK7sVmdR4WbEpODhRGeTtcZJ8yBSZM898jKQRy2vK
-pYRyaADNsWDlvujVkjMr/a40KrIaPQ3h3LZNUaYYaQKBgQD1x8A5S5SiE1cN1vFr
-aACkmA2WqEDKKhUsUigJdwW6WB/B9kWlIlz/iV1H9uwBXtSIYG4VqCSTAvh0z4gX
-Qu2SrdPm5PYnKzpdynpz78OnGdflD1RKWFGHItR6GN6tj/VmulO6mlFvT4jzBQ7j
-+Hf8m2TcD4U3ksz3xw+YOD+cmA==
-----END RSA PRIVATE KEY-----
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
-.idea
 /target
 *.deb
-.vscode
+.idea/*
+tests/ruby/.bundle/*
+tests/ruby/vendor/*
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -10,4 +10,10 @@ Happy hacking!

 ## TODOs

-See [Issues]([url](https://github.com/levkk/pgcat/issues)).
+A non-exhaustive list of things that would be useful to implement:
+
+#### Client authentication
+MD5 is probably sufficient, but maybe others too.
+
+#### Admin
+Admin database for stats collection and pooler administration. PgBouncer gives us a nice example on how to do that, specifically how to implement `RowDescription` and `DataRow` messages, [example here](https://github.com/pgbouncer/pgbouncer/blob/4f9ced8e63d317a6ff45c8b0efa876b32161f6db/src/admin.c#L813).
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -45,22 +45,16 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"

-[[package]]
-name = "base64"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
-
 [[package]]
 name = "bb8"
-version = "0.8.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1627eccf3aa91405435ba240be23513eeca466b5dc33866422672264de061582"
+checksum = "2e9f4fa9768efd269499d8fba693260cfc670891cf6de3adc935588447a77cc8"
 dependencies = [
 "async-trait",
 "futures-channel",
 "futures-util",
- "parking_lot 0.12.1",
+ "parking_lot",
 "tokio",
 ]

@@ -79,24 +73,12 @@ dependencies = [
 "generic-array",
 ]

-[[package]]
-name = "bumpalo"
-version = "3.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37ccbd214614c6783386c1af30caf03192f17891059cecc394b4fb119e363de3"
-
 [[package]]
 name = "bytes"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"

-[[package]]
-name = "cc"
-version = "1.0.73"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
-
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -127,23 +109,22 @@ dependencies = [

 [[package]]
 name = "crypto-common"
-version = "0.1.3"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8"
+checksum = "683d6b536309245c849479fba3da410962a43ed8e51c26b729208ec0ac2798d0"
 dependencies = [
 "generic-array",
- "typenum",
 ]

 [[package]]
 name = "digest"
-version = "0.10.3"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2fb860ca6fafa5552fb6d0e816a69c8e49f0908bf524e30a90d97c85892d506"
+checksum = "b697d66081d42af4fba142d56918a3cb21dc8eb63372c6b85d14f44fb9c5979b"
 dependencies = [
 "block-buffer",
 "crypto-common",
- "subtle",
+ "generic-array",
 ]

 [[package]]
@@ -159,18 +140,6 @@ dependencies = [
 "termcolor",
 ]

-[[package]]
-name = "exitcode"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de853764b47027c2e862a995c34978ffa63c1501f2e15f987ba11bd4f9bba193"
-
-[[package]]
-name = "fnv"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
 [[package]]
 name = "futures-channel"
 version = "0.3.19"
@@ -186,12 +155,6 @@ version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0c8ff0461b82559810cdccfde3215c3f373807f5e5232b71479bff7bb2583d7"

-[[package]]
-name = "futures-sink"
-version = "0.3.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21163e139fa306126e6eedaf49ecdb4588f939600f0b1e770f4205ee4b7fa868"
-
 [[package]]
 name = "futures-task"
 version = "0.3.19"
@@ -233,31 +196,6 @@ dependencies = [
 "wasi",
 ]

-[[package]]
-name = "h2"
-version = "0.3.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37a82c6d637fc9515a4694bbf1cb2457b79d81ce52b3108bdeea58b07dd34a57"
-dependencies = [
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http",
- "indexmap",
- "slab",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
@@ -267,89 +205,12 @@ dependencies = [
 "libc",
 ]

-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "http"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75f43d41e26995c17e71ee126451dd3941010b0514a81a9d11f3b341debc2399"
-dependencies = [
- "bytes",
- "fnv",
- "itoa",
-]
-
-[[package]]
-name = "http-body"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
-dependencies = [
- "bytes",
- "http",
- "pin-project-lite",
-]
-
-[[package]]
-name = "httparse"
-version = "1.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "496ce29bb5a52785b44e0f7ca2847ae0bb839c9bd28f69acac9b99d461c0c04c"
-
-[[package]]
-name = "httpdate"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
-
 [[package]]
 name = "humantime"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"

-[[package]]
-name = "hyper"
-version = "0.14.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02c929dc5c39e335a03c405292728118860721b10190d98c2a0f0efd5baafbac"
-dependencies = [
- "bytes",
- "futures-channel",
- "futures-core",
- "futures-util",
- "h2",
- "http",
- "http-body",
- "httparse",
- "httpdate",
- "itoa",
- "pin-project-lite",
- "socket2",
- "tokio",
- "tower-service",
- "tracing",
- "want",
-]
-
-[[package]]
-name = "indexmap"
-version = "1.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"
-dependencies = [
- "autocfg",
- "hashbrown",
-]
-
 [[package]]
 name = "instant"
 version = "0.1.12"
@@ -361,30 +222,15 @@ dependencies = [

 [[package]]
 name = "itoa"
-version = "1.0.3"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8af84674fe1f223a982c933a0ee1086ac4d4052aa0fb8060c12c6ad838e754"
-
-[[package]]
-name = "js-sys"
-version = "0.3.58"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3fac17f7123a73ca62df411b1bf727ccc805daa070338fda671c86dac1bdc27"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"

 [[package]]
 name = "libc"
-version = "0.2.126"
+version = "0.2.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+checksum = "e74d72e0f9b65b5b4ca49a346af3976df0f9c61d550727f349ecd559f251a26c"

 [[package]]
 name = "lock_api"
@@ -493,17 +339,7 @@ checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
 dependencies = [
 "instant",
 "lock_api",
- "parking_lot_core 0.8.5",
-]
-
-[[package]]
-name = "parking_lot"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
-dependencies = [
- "lock_api",
- "parking_lot_core 0.9.3",
+ "parking_lot_core",
 ]

 [[package]]
@@ -520,95 +356,33 @@ dependencies = [
 "winapi",
 ]

-[[package]]
-name = "parking_lot_core"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09a279cbf25cb0757810394fbc1e359949b59e348145c643a939a525692e6929"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-sys",
-]
-
 [[package]]
 name = "pgcat"
-version = "0.6.0-alpha1"
+version = "0.1.0"
 dependencies = [
 "arc-swap",
 "async-trait",
- "base64",
 "bb8",
 "bytes",
 "chrono",
 "env_logger",
- "exitcode",
- "hmac",
- "hyper",
 "log",
 "md-5",
 "num_cpus",
 "once_cell",
- "parking_lot 0.12.1",
- "phf",
+ "parking_lot",
 "rand",
 "regex",
- "rustls-pemfile",
 "serde",
 "serde_derive",
+ "serde_json",
 "sha-1",
- "sha2",
 "sqlparser",
- "stringprep",
+ "statsd",
 "tokio",
- "tokio-rustls",
 "toml",
 ]

-[[package]]
-name = "phf"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "928c6535de93548188ef63bb7c4036bd415cd8f36ad25af44b9789b2ee72a48c"
-dependencies = [
- "phf_macros",
- "phf_shared",
-]
-
-[[package]]
-name = "phf_generator"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1181c94580fa345f50f19d738aaa39c0ed30a600d95cb2d3e23f94266f14fbf"
-dependencies = [
- "phf_shared",
- "rand",
-]
-
-[[package]]
-name = "phf_macros"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92aacdc5f16768709a569e913f7451034034178b05bdc8acda226659a3dccc66"
-dependencies = [
- "phf_generator",
- "phf_shared",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1fb5f6f826b772a8d4c0394209441e7d37cbbb967ae9c7e0e8134365c9ee676"
-dependencies = [
- "siphasher",
-]
-
 [[package]]
 name = "pin-project-lite"
 version = "0.2.8"
@@ -696,9 +470,9 @@ dependencies = [

 [[package]]
 name = "regex"
-version = "1.5.5"
+version = "1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a11647b6b25ff05a515cb92c365cec08801e83423a235b51e231e1808747286"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
 dependencies = [
 "aho-corasick",
 "memchr",
@@ -712,40 +486,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"

 [[package]]
-name = "ring"
-version = "0.16.20"
+name = "ryu"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
-dependencies = [
- "cc",
- "libc",
- "once_cell",
- "spin",
- "untrusted",
- "web-sys",
- "winapi",
-]
-
-[[package]]
-name = "rustls"
-version = "0.20.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aab8ee6c7097ed6057f43c187a62418d0c05a4bd5f18b3571db50ee0f9ce033"
-dependencies = [
- "log",
- "ring",
- "sct",
- "webpki",
-]
-
-[[package]]
-name = "rustls-pemfile"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7522c9de787ff061458fe9a829dc790a3f5b22dc571694fc5883f448b94d9a9"
-dependencies = [
- "base64",
-]
+checksum = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"

 [[package]]
 name = "scopeguard"
@@ -753,16 +497,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"

-[[package]]
-name = "sct"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
-dependencies = [
- "ring",
- "untrusted",
-]
-
 [[package]]
 name = "serde"
 version = "1.0.136"
@@ -780,6 +514,17 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "serde_json"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e8d9fa5c3b304765ce1fd9c4c8a3de2c8db365a5b91be52f186efc675681d95"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
 [[package]]
 name = "sha-1"
 version = "0.10.0"
@@ -791,17 +536,6 @@ dependencies = [
 "digest",
 ]

-[[package]]
-name = "sha2"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55deaec60f81eefe3cce0dc50bda92d6d8e88f2a27df7c5033b42afeb1ed2676"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.0"
@@ -811,12 +545,6 @@ dependencies = [
 "libc",
 ]

-[[package]]
-name = "siphasher"
-version = "0.3.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
-
 [[package]]
 name = "slab"
 version = "0.4.5"
@@ -829,47 +557,24 @@ version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"

-[[package]]
-name = "socket2"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66d72b759436ae32898a2af0a14218dbf55efde3feeb170eb623637db85ee1e0"
-dependencies = [
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
 [[package]]
 name = "sqlparser"
-version = "0.23.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0beb13adabbdda01b63d595f38c8bfd19a361e697fd94ce0098a634077bc5b25"
+checksum = "b8f192f29f4aa49e57bebd0aa05858e0a1f32dd270af36efe49edb82cbfffab6"
 dependencies = [
 "log",
 ]

 [[package]]
-name = "stringprep"
-version = "0.1.2"
+name = "statsd"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ee348cb74b87454fff4b551cbf727025810a004f88aeacae7f85b87f4e9a1c1"
+checksum = "df1efceb4bf2c0b5ebec94354285a43bbbed1375605bdf2ebe4132299434a330"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "rand",
 ]

-[[package]]
-name = "subtle"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
-
 [[package]]
 name = "syn"
 version = "1.0.86"
@@ -901,21 +606,6 @@ dependencies = [
 "winapi",
 ]

-[[package]]
-name = "tinyvec"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
-
 [[package]]
 name = "tokio"
 version = "1.16.1"
@@ -928,7 +618,7 @@ dependencies = [
 "mio",
 "num_cpus",
 "once_cell",
- "parking_lot 0.11.2",
+ "parking_lot",
 "pin-project-lite",
 "signal-hook-registry",
 "tokio-macros",
@@ -946,31 +636,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "tokio-rustls"
-version = "0.23.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c43ee83903113e03984cb9e5cebe6c04a5116269e900e3ddba8f068a62adda59"
-dependencies = [
- "rustls",
- "tokio",
- "webpki",
-]
-
-[[package]]
-name = "tokio-util"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f988a1a1adc2fb21f9c12aa96441da33a1728193ae0b95d2be22dbd17fcb4e5c"
-dependencies = [
- "bytes",
- "futures-core",
- "futures-sink",
- "pin-project-lite",
- "tokio",
- "tracing",
-]
-
 [[package]]
 name = "toml"
 version = "0.5.8"
@@ -980,179 +645,30 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "tower-service"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
-
-[[package]]
-name = "tracing"
-version = "0.1.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d0ecdcb44a79f0fe9844f0c4f33a342cbcbb5117de8001e6ba0dc2351327d09"
-dependencies = [
- "cfg-if",
- "pin-project-lite",
- "tracing-attributes",
- "tracing-core",
-]
-
-[[package]]
-name = "tracing-attributes"
-version = "0.1.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11c75893af559bc8e10716548bdef5cb2b983f8e637db9d0e15126b61b484ee2"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "tracing-core"
-version = "0.1.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f54c8ca710e81886d498c2fd3331b56c93aa248d49de2222ad2742247c60072f"
-dependencies = [
- "lazy_static",
-]
-
-[[package]]
-name = "try-lock"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
-
 [[package]]
 name = "typenum"
 version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"

-[[package]]
-name = "unicode-bidi"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
-dependencies = [
- "tinyvec",
-]
-
 [[package]]
 name = "unicode-xid"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"

-[[package]]
-name = "untrusted"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
-
 [[package]]
 name = "version_check"
 version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

-[[package]]
-name = "want"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
-dependencies = [
- "log",
- "try-lock",
-]
-
 [[package]]
 name = "wasi"
 version = "0.10.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"

-[[package]]
-name = "wasm-bindgen"
-version = "0.2.81"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c53b543413a17a202f4be280a7e5c62a1c69345f5de525ee64f8cfdbc954994"
-dependencies = [
- "cfg-if",
- "wasm-bindgen-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.81"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5491a68ab4500fa6b4d726bd67408630c3dbe9c4fe7bda16d5c82a1fd8c7340a"
-dependencies = [
- "bumpalo",
- "lazy_static",
- "log",
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.81"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c441e177922bc58f1e12c022624b6216378e5febc2f0533e41ba443d505b80aa"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.81"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d94ac45fcf608c1f45ef53e748d35660f168490c10b23704c7779ab8f5c3048"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.81"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a89911bd99e5f3659ec4acf9c4d93b0a90fe4a2a11f15328472058edc5261be"
-
-[[package]]
-name = "web-sys"
-version = "0.3.58"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fed94beee57daf8dd7d51f2b15dc2bcde92d7a72304cdf662a4371008b71b90"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "webpki"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
-dependencies = [
- "ring",
- "untrusted",
-]
-
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -1183,46 +699,3 @@ name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "windows-sys"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
-dependencies = [
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pgcat"
-version = "0.6.0-alpha1"
+version = "0.1.0"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -9,7 +9,7 @@ edition = "2021"
 tokio = { version = "1", features = ["full"] }
 bytes = "1"
 md-5 = "0.10"
-bb8 = "0.8.0"
+bb8 = "0.7"
 async-trait = "0.1"
 rand = "0.8"
 chrono = "0.4"
@@ -17,20 +17,13 @@ sha-1 = "0.10"
 toml = "0.5"
 serde = "1"
 serde_derive = "1"
+serde_json = "1"
 regex = "1"
 num_cpus = "1"
 once_cell = "1"
-sqlparser = "0.23.0"
+statsd = "0.15"
+sqlparser = "0.14"
 log = "0.4"
 arc-swap = "1"
 env_logger = "0.9"
-parking_lot = "0.12.1"
-hmac = "0.12"
-sha2 = "0.10"
-base64 = "0.13"
-stringprep = "0.1"
-tokio-rustls = "0.23"
-rustls-pemfile = "1"
-hyper = { version = "0.14", features = ["full"] }
-phf = { version = "0.11.1", features = ["macros"] }
-exitcode = "1.1.2"
+parking_lot = "0.11"
--- a/6
+++ b/6
@@ -1,11 +1,11 @@
-FROM rust:1 AS builder
+FROM rust:1.58-slim-buster AS builder
 COPY . /app
 WORKDIR /app
 RUN cargo build --release

-FROM debian:bullseye-slim
+FROM debian:buster-slim
 COPY --from=builder /app/target/release/pgcat /usr/bin/pgcat
 COPY --from=builder /app/pgcat.toml /etc/pgcat/pgcat.toml
 WORKDIR /etc/pgcat
 ENV RUST_LOG=info
-CMD ["pgcat"]
+ENTRYPOINT ["/usr/bin/pgcat"]
--- a/Dockerfile.ci
+++ b/Dockerfile.ci
@@ -1,8 +0,0 @@
-FROM cimg/rust:1.62.0
-RUN sudo apt-get update && \
-	sudo apt-get install -y psmisc postgresql-contrib-12 postgresql-client-12 ruby ruby-dev libpq-dev python3 python3-pip lcov llvm-11 && \
-	sudo apt-get upgrade curl
-RUN cargo install cargo-binutils rustfilt && \
-	rustup component add llvm-tools-preview
-RUN pip3 install psycopg2 && \
-	sudo gem install bundler
--- a/README.md
+++ b/README.md
@@ -1,75 +1,57 @@
-![PgCat](./pgcat3.png)
-
-##### PgCat: PostgreSQL at petabyte scale
+# PgCat

 [![CircleCI](https://circleci.com/gh/levkk/pgcat/tree/main.svg?style=svg)](https://circleci.com/gh/levkk/pgcat/tree/main)
-<a href="https://discord.gg/DmyJP3qJ7U" target="_blank">
-    <img src="https://img.shields.io/discord/1013868243036930099" alt="Join our Discord!" />
-</a>

-PostgreSQL pooler (like PgBouncer) with sharding, load balancing and failover support.
+![PgCat](./pgcat3.png)

-**Beta**: looking for beta testers, see [#35](https://github.com/levkk/pgcat/issues/35).
+Meow. PgBouncer rewritten in Rust, with sharding, load balancing and failover support.
+
+**Alpha**: looking for alpha testers, see [#35](https://github.com/levkk/pgcat/issues/35).

 ## Features
-| **Feature**                    | **Status**                  | **Comments**                                                                                                                                          |
-|--------------------------------|-----------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Transaction pooling            | :white_check_mark:          | Identical to PgBouncer.                                                                                                                               |
-| Session pooling                | :white_check_mark:          | Identical to PgBouncer.                                                                                                                               |
-| `COPY` support                 | :white_check_mark:          | Both `COPY TO` and `COPY FROM` are supported.                                                                                                         |
-| Query cancellation             | :white_check_mark:          | Supported both in transaction and session pooling modes.                                                                                              |
-| Load balancing of read queries | :white_check_mark:          | Using random between replicas. Primary is included when `primary_reads_enabled` is enabled (default).                                            |
-| Sharding                       | :white_check_mark:          | Transactions are sharded using `SET SHARD TO` and `SET SHARDING KEY TO` syntax extensions; see examples below.                                        |
-| Failover                       | :white_check_mark:          | Replicas are tested with a health check. If a health check fails, remaining replicas are attempted; see below for algorithm description and examples. |
-| Statistics                     | :white_check_mark:          | Statistics available in the admin database (`pgcat` and `pgbouncer`) with `SHOW STATS`, `SHOW POOLS` and others.                                      |
-| Live configuration reloading   | :white_check_mark:          | Reload supported settings with a `SIGHUP` to the process, e.g. `kill -s SIGHUP $(pgrep pgcat)` or `RELOAD` query issued to the admin database.        |
-| Client authentication          | :white_check_mark: :wrench: | MD5 password authentication is supported, SCRAM is on the roadmap; one user is used to connect to Postgres with both SCRAM and MD5 supported.         |
-| Admin database                 | :white_check_mark:          | The admin database, similar to PgBouncer's, allows to query for statistics and reload the configuration.                                              |
+| **Feature**                    | **Status**            | **Comments**                                                                                                                                          |
+|--------------------------------|-----------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Transaction pooling            | :white_check_mark:    | Identical to PgBouncer.                                                                                                                               |
+| Session pooling                | :white_check_mark:    | Identical to PgBouncer.                                                                                                                               |
+| `COPY` support                 | :white_check_mark:    | Both `COPY TO` and `COPY FROM` are supported.                                                                                                         |
+| Query cancellation             | :white_check_mark:    | Supported both in transaction and session pooling modes.                                                                                              |
+| Load balancing of read queries | :white_check_mark:    | Using round-robin between replicas. Primary is included when `primary_reads_enabled` is enabled (default).                                            |
+| Sharding                       | :white_check_mark:    | Transactions are sharded using `SET SHARD TO` and `SET SHARDING KEY TO` syntax extensions; see examples below.                                        |
+| Failover                       | :white_check_mark:    | Replicas are tested with a health check. If a health check fails, remaining replicas are attempted; see below for algorithm description and examples. |
+| Statistics reporting           | :white_check_mark:    | Statistics similar to PgBouncers are reported via StatsD.                                                                                             |
+| Live configuration reloading   | :construction_worker: | Reload config with a `SIGHUP` to the process, e.g. `kill -s SIGHUP $(pgrep pgcat)`. Not all settings can be reloaded without a restart.               |
+| Client authentication          | :x: :wrench:          | On the roadmap; currently all clients are allowed to connect and one user is used to connect to Postgres.                                             |

 ## Deployment

-See `Dockerfile` for example deployment using Docker. The pooler is configured to spawn 4 workers so 4 CPUs are recommended for optimal performance. That setting can be adjusted to spawn as many (or as little) workers as needed.
-
-For quick local example, use the Docker Compose environment provided:
-
-```bash
-docker-compose up
-
-# In a new terminal:
-psql -h 127.0.0.1 -p 6432 -c 'SELECT 1'
-```
+See `Dockerfile` for example deployment using Docker. The pooler is configured to spawn 4 workers so 4 CPUs are recommended for optimal performance.
+That setting can be adjusted to spawn as many (or as little) workers as needed.

 ### Config

-| **Name**                     | **Description**                                                                                                                            | **Examples**                     |
-|------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------|
-| **`general`**                |                                                                                                                                            |                                  |
-| `host`                       | The pooler will run on this host, 0.0.0.0 means accessible from everywhere.                                                                | `0.0.0.0`                        |
-| `port`                       | The pooler will run on this port.                                                                                                          | `6432`                           |
-| `enable_prometheus_exporter` | Enable prometheus exporter which will export metrics in prometheus exposition format.                                                      | `true`                           |
-| `prometheus_exporter_port`   | Port at which prometheus exporter listens on.                                                                                              | `9930`                           |
-| `pool_size`                  | Maximum allowed server connections per pool. Pools are separated for each user/shard/server role. The connections are allocated as needed. | `15`                             |
-| `pool_mode`                  | The pool mode to use, i.e. `session` or `transaction`.                                                                                     | `transaction`                    |
-| `connect_timeout`            | Maximum time to establish a connection to a server (milliseconds). If reached, the server is banned and the next target is attempted.      | `5000`                           |
-| `healthcheck_timeout`        | Maximum time to pass a health check (`SELECT 1`, milliseconds). If reached, the server is banned and the next target is attempted.         | `1000`                           |
-| `shutdown_timeout`           | Maximum time to give clients during shutdown before forcibly killing client connections (ms).                                              | `60000`                          |
-| `healthcheck_delay`          | How long to keep connection available for immediate re-use, without running a healthcheck query on it                                      | `30000`                          |
-| `ban_time`                   | Ban time for a server (seconds). It won't be allowed to serve transactions until the ban expires; failover targets will be used instead.   | `60`                             |
-| `autoreload`                 | Enable auto-reload of config after fixed time-interval.                                                                                    | `false`                          |
-|                              |                                                                                                                                            |                                  |
-| **`user`**                   |                                                                                                                                            |                                  |
-| `name`                       | The user name.                                                                                                                             | `sharding_user`                  |
-| `password`                   | The user password in plaintext.                                                                                                            | `hunter2`                        |
-| `statement_timeout` | Timeout in milliseconds for how long a query takes to execute | `0 (disabled)`
-|                              |                                                                                                                                            |                                  |
-| **`shards`**                 | Shards are numerically numbered starting from 0; the order in the config is preserved by the pooler to route queries accordingly.          | `[shards.0]`                     |
-| `servers`                    | List of servers to connect to and their roles. A server is: `[host, port, role]`, where `role` is either `primary` or `replica`.           | `["127.0.0.1", 5432, "primary"]` |
-| `database`                   | The name of the database to connect to. This is the same on all servers that are part of one shard.                                        |                                  |
-|                              |                                                                                                                                            |                                  |
-| **`query_router`**           |                                                                                                                                            |                                  |
-| `default_role`               | Traffic is routed to this role by default (random), unless the client specifies otherwise. Default is `any`, for any role available.  | `any`, `primary`, `replica`      |
-| `query_parser_enabled`       | Enable the query parser which will inspect incoming queries and route them to a primary or replicas.                                       | `false`                          |
-| `primary_reads_enabled`      | Enable this to allow read queries on the primary; otherwise read queries are routed to the replicas.                                       | `true`                           |
+| **Name**                | **Description**                                                                                                                            | **Examples**                     |
+|-------------------------|--------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------|
+| **`general`**           |                                                                                                                                            |                                  |
+| `host`                  | The pooler will run on this host, 0.0.0.0 means accessible from everywhere.                                                                | `0.0.0.0`                        |
+| `port`                  | The pooler will run on this port.                                                                                                          | `6432`                           |
+| `pool_size`             | Maximum allowed server connections per pool. Pools are separated for each user/shard/server role. The connections are allocated as needed. | `15`                             |
+| `pool_mode`             | The pool mode to use, i.e. `session` or `transaction`.                                                                                     | `transaction`                    |
+| `connect_timeout`       | Maximum time to establish a connection to a server (milliseconds). If reached, the server is banned and the next target is attempted.      | `5000`                           |
+| `healthcheck_timeout`   | Maximum time to pass a health check (`SELECT 1`, milliseconds). If reached, the server is banned and the next target is attempted.         | `1000`                           |
+| `ban_time`              | Ban time for a server (seconds). It won't be allowed to serve transactions until the ban expires; failover targets will be used instead.   | `60`                             |
+| `statsd_address`        | StatsD host and port. Statistics will be sent there every 15 seconds.                                                                      | `127.0.0.1:8125`                 |
+|                         |                                                                                                                                            |                                  |
+| **`user`**              |                                                                                                                                            |                                  |
+| `name`                  | The user name.                                                                                                                             | `sharding_user`                  |
+| `password`              | The user password in plaintext.                                                                                                            | `hunter2`                        |
+|                         |                                                                                                                                            |                                  |
+| **`shards`**            | Shards are numerically numbered starting from 0; the order in the config is preserved by the pooler to route queries accordingly.          | `[shards.0]`                     |
+| `servers`               | List of servers to connect to and their roles. A server is: `[host, port, role]`, where `role` is either `primary` or `replica`.           | `["127.0.0.1", 5432, "primary"]` |
+| `database`              | The name of the database to connect to. This is the same on all servers that are part of one shard.                                        |                                  |
+| **`query_router`**      |                                                                                                                                            |                                  |
+| `default_role`          | Traffic is routed to this role by default (round-robin), unless the client specifies otherwise. Default is `any`, for any role available.  | `any`, `primary`, `replica`      |
+| `query_parser_enabled`  | Enable the query parser which will inspect incoming queries and route them to a primary or replicas.                                       | `false`                          |
+| `primary_reads_enabled` | Enable this to allow read queries on the primary; otherwise read queries are routed to the replicas.                                       | `true`                           |

 ## Local development

@@ -91,14 +73,6 @@ pgbench -t 1000 -p 6432 -h 127.0.0.1 --protocol extended

 See [sharding README](./tests/sharding/README.md) for sharding logic testing.

-Run `cargo test` to run Rust tests.
-
-Run the following commands to run Integration tests locally.
-```
-cd tests/docker/
-docker compose up --exit-code-from main # This will also produce coverage report under ./cov/
-```
-
 | **Feature**           | **Tested in CI**   | **Tested manually** | **Comments**                                                                                                             |
 |-----------------------|--------------------|---------------------|--------------------------------------------------------------------------------------------------------------------------|
 | Transaction pooling   | :white_check_mark: | :white_check_mark:  | Used by default for all tests.                                                                                           |
@@ -108,7 +82,7 @@ docker compose up --exit-code-from main # This will also produce coverage report
 | Load balancing        | :white_check_mark: | :white_check_mark:  | We could test this by emitting statistics for each replica and compare them.                                             |
 | Failover              | :white_check_mark: | :white_check_mark:  | Misconfigure a replica in `pgcat.toml` and watch it forward queries to spares. CI testing is using Toxiproxy.            |
 | Sharding              | :white_check_mark: | :white_check_mark:  | See `tests/sharding` and `tests/ruby` for an Rails/ActiveRecord example.                                                 |
-| Statistics            | :white_check_mark: | :white_check_mark:  | Query the admin database with `psql -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW STATS'`.                                  |
+| Statistics reporting  | :x:                | :white_check_mark:  | Run `nc -l -u 8125` and watch the stats come in every 15 seconds.                                                        |
 | Live config reloading | :white_check_mark: | :white_check_mark:  | Run `kill -s SIGHUP $(pgrep pgcat)` and watch the config reload.                                                         |

 ## Usage
@@ -124,7 +98,7 @@ In transaction mode, a client talks to one server for the duration of a single t
 This mode is enabled by default.

 ### Load balancing of read queries
-All queries are load balanced against the configured servers using the random algorithm. The most straight forward configuration example would be to put this pooler in front of several replicas and let it load balance all queries.
+All queries are load balanced against the configured servers using the round-robin algorithm. The most straight forward configuration example would be to put this pooler in front of several replicas and let it load balance all queries.

 If the configuration includes a primary and replicas, the queries can be separated with the built-in query parser. The query parser will interpret the query and route all `SELECT` queries to a replica, while all other queries including explicit transactions will be routed to the primary.

@@ -163,18 +137,18 @@ Failover behavior can get pretty interesting (read complex) when multiple config

 | **Query**                 | **`SET SERVER ROLE TO`** | **`query_parser_enabled`** | **`primary_reads_enabled`** | **Target state** | **Outcome**                                                                                                                                                          |
 |---------------------------|--------------------------|----------------------------|-----------------------------|------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Read query, i.e. `SELECT` | unset (any)              | false                      | false                       | up               | Query is routed to the first instance in the random loop.                                                                                                       |
-| Read query                | unset (any)              | true                       | false                       | up               | Query is routed to the first replica instance in the random loop.                                                                                               |
-| Read query                | unset (any)              | true                       | true                        | up               | Query is routed to the first instance in the random loop.                                                                                                       |
-| Read query                | replica                  | false                      | false                       | up               | Query is routed to the first replica instance in the random loop.                                                                                               |
+| Read query, i.e. `SELECT` | unset (any)              | false                      | false                       | up               | Query is routed to the first instance in the round-robin loop.                                                                                                       |
+| Read query                | unset (any)              | true                       | false                       | up               | Query is routed to the first replica instance in the round-robin loop.                                                                                               |
+| Read query                | unset (any)              | true                       | true                        | up               | Query is routed to the first instance in the round-robin loop.                                                                                                       |
+| Read query                | replica                  | false                      | false                       | up               | Query is routed to the first replica instance in the round-robin loop.                                                                                               |
 | Read query                | primary                  | false                      | false                       | up               | Query is routed to the primary.                                                                                                                                      |
-| Read query                | unset (any)              | false                      | false                       | down             | First instance is banned for reads. Next target in the random loop is attempted.                                                                                |
-| Read query                | unset (any)              | true                       | false                       | down             | First replica instance is banned. Next replica instance is attempted in the random loop.                                                                        |
-| Read query                | unset (any)              | true                       | true                        | down             | First instance (even if primary) is banned for reads. Next instance is attempted in the random loop.                                                            |
-| Read query                | replica                  | false                      | false                       | down             | First replica instance is banned. Next replica instance is attempted in the random loop.                                                                        |
+| Read query                | unset (any)              | false                      | false                       | down             | First instance is banned for reads. Next target in the round-robin loop is attempted.                                                                                |
+| Read query                | unset (any)              | true                       | false                       | down             | First replica instance is banned. Next replica instance is attempted in the round-robin loop.                                                                        |
+| Read query                | unset (any)              | true                       | true                        | down             | First instance (even if primary) is banned for reads. Next instance is attempted in the round-robin loop.                                                            |
+| Read query                | replica                  | false                      | false                       | down             | First replica instance is banned. Next replica instance is attempted in the round-robin loop.                                                                        |
 | Read query                | primary                  | false                      | false                       | down             | The query is attempted against the primary and fails. The client receives an error.                                                                                  |
 |                           |                          |                            |                             |                  |                                                                                                                                                                      |
-| Write query e.g. `INSERT` | unset (any)              | false                      | false                       | up               | The query is attempted against the first available instance in the random loop. If the instance is a replica, the query fails and the client receives an error. |
+| Write query e.g. `INSERT` | unset (any)              | false                      | false                       | up               | The query is attempted against the first available instance in the round-robin loop. If the instance is a replica, the query fails and the client receives an error. |
 | Write query               | unset (any)              | true                       | false                       | up               | The query is routed to the primary.                                                                                                                                  |
 | Write query               | unset (any)              | true                       | true                        | up               | The query is routed to the primary.                                                                                                                                  |
 | Write query               | primary                  | false                      | false                       | up               | The query is routed to the primary.                                                                                                                                  |
@@ -251,15 +225,11 @@ SELECT * FROM users WHERE email = 'test@example.com'; -- shard setting lasts unt

 ### Statistics reporting

-The stats are very similar to what Pgbouncer reports and the names are kept to be comparable. They are accessible by querying the admin database `pgcat`, and `pgbouncer` for compatibility.
-
-```
-psql -h 127.0.0.1 -p 6432 -d pgbouncer -c 'SHOW DATABASES'
-```
+Stats are reported using StatsD every 15 seconds. The address is configurable with `statsd_address`, the default is `127.0.0.1:8125`. The stats are very similar to what Pgbouncer reports and the names are kept to be comparable.

 ### Live configuration reloading

-The config can be reloaded by sending a `kill -s SIGHUP` to the process or by querying `RELOAD` to the admin database. Not all settings are currently supported by live reload:
+The config can be reloaded by sending a `kill -s SIGHUP` to the process. Not all settings are currently supported by live reload:

 | **Config**              | **Requires restart** |
 |-------------------------|----------------------|
@@ -268,9 +238,8 @@ The config can be reloaded by sending a `kill -s SIGHUP` to the process or by qu
 | `pool_mode`             | no                   |
 | `connect_timeout`       | yes                  |
 | `healthcheck_timeout`   | no                   |
-| `shutdown_timeout`      | no                   |
-| `healthcheck_delay`     | no                   |
 | `ban_time`              | no                   |
+| `statsd_address`        | yes                  |
 | `user`                  | yes                  |
 | `shards`                | yes                  |
 | `default_role`          | no                   |
@@ -459,7 +428,7 @@ Always good to have a base line.

 ```
 $ pgbench -t 1000 -c 16 -j 2 -p 5432 -h 127.0.0.1 -S --protocol extended shard0
-Password:
+Password: 
 starting vacuum...end.
 transaction type: <builtin: select only>
 scaling factor: 1
@@ -473,7 +442,7 @@ tps = 139443.955722 (including connections establishing)
 tps = 142314.859075 (excluding connections establishing)

 $ pgbench -t 1000 -c 32 -j 2 -p 5432 -h 127.0.0.1 -S --protocol extended shard0
-Password:
+Password: 
 starting vacuum...end.
 transaction type: <builtin: select only>
 scaling factor: 1
@@ -487,7 +456,7 @@ tps = 150644.840891 (including connections establishing)
 tps = 152218.499430 (excluding connections establishing)

 $ pgbench -t 1000 -c 64 -j 2 -p 5432 -h 127.0.0.1 -S --protocol extended shard0
-Password:
+Password: 
 starting vacuum...end.
 transaction type: <builtin: select only>
 scaling factor: 1
@@ -501,7 +470,7 @@ tps = 152517.663404 (including connections establishing)
 tps = 153319.188482 (excluding connections establishing)

 $ pgbench -t 1000 -c 128 -j 2 -p 5432 -h 127.0.0.1 -S --protocol extended shard0
-Password:
+Password: 
 starting vacuum...end.
 transaction type: <builtin: select only>
 scaling factor: 1
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,17 +0,0 @@
-version: "3"
-services:
-  postgres:
-    image: postgres:14
-    environment:
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_HOST_AUTH_METHOD: md5
-  pgcat:
-    build: .
-    command:
-      - "pgcat"
-      - "/etc/pgcat/pgcat.toml"
-    volumes:
-      - "${PWD}/examples/docker/pgcat.toml:/etc/pgcat/pgcat.toml"
-    ports:
-      - "6432:6432"
-      - "9930:9930"
--- a/examples/docker/pgcat.toml
+++ b/examples/docker/pgcat.toml
@@ -1,147 +0,0 @@
-#
-# PgCat config example.
-#
-
-#
-# General pooler settings
-[general]
-# What IP to run on, 0.0.0.0 means accessible from everywhere.
-host = "0.0.0.0"
-
-# Port to run on, same as PgBouncer used in this example.
-port = 6432
-
-# Whether to enable prometheus exporter or not.
-enable_prometheus_exporter = true
-
-# Port at which prometheus exporter listens on.
-prometheus_exporter_port = 9930
-
-# How long to wait before aborting a server connection (ms).
-connect_timeout = 5000
-
-# How much time to give `SELECT 1` health check query to return with a result (ms).
-healthcheck_timeout = 1000
-
-# How long to keep connection available for immediate re-use, without running a healthcheck query on it
-healthcheck_delay = 30000
-
-# How much time to give clients during shutdown before forcibly killing client connections (ms).
-shutdown_timeout = 60000
-
-# For how long to ban a server if it fails a health check (seconds).
-ban_time = 60 # seconds
-
-# Reload config automatically if it changes.
-autoreload = false
-
-# TLS
-# tls_certificate = "server.cert"
-# tls_private_key = "server.key"
-
-# Credentials to access the virtual administrative database (pgbouncer or pgcat)
-# Connecting to that database allows running commands like `SHOW POOLS`, `SHOW DATABASES`, etc..
-admin_username = "postgres"
-admin_password = "postgres"
-
-# pool
-# configs are structured as pool.<pool_name>
-# the pool_name is what clients use as database name when connecting
-# For the example below a client can connect using "postgres://sharding_user:sharding_user@pgcat_host:pgcat_port/sharded"
-[pools.sharded]
-# Pool mode (see PgBouncer docs for more).
-# session: one server connection per connected client
-# transaction: one server connection per client transaction
-pool_mode = "transaction"
-
-# If the client doesn't specify, route traffic to
-# this role by default.
-#
-# any: round-robin between primary and replicas,
-# replica: round-robin between replicas only without touching the primary,
-# primary: all queries go to the primary unless otherwise specified.
-default_role = "any"
-
-# Query parser. If enabled, we'll attempt to parse
-# every incoming query to determine if it's a read or a write.
-# If it's a read query, we'll direct it to a replica. Otherwise, if it's a write,
-# we'll direct it to the primary.
-query_parser_enabled = true
-
-# If the query parser is enabled and this setting is enabled, the primary will be part of the pool of databases used for
-# load balancing of read queries. Otherwise, the primary will only be used for write
-# queries. The primary can always be explicitely selected with our custom protocol.
-primary_reads_enabled = true
-
-# So what if you wanted to implement a different hashing function,
-# or you've already built one and you want this pooler to use it?
-#
-# Current options:
-#
-# pg_bigint_hash: PARTITION BY HASH (Postgres hashing function)
-# sha1: A hashing function based on SHA1
-#
-sharding_function = "pg_bigint_hash"
-
-# Credentials for users that may connect to this cluster
-[pools.sharded.users.0]
-username = "postgres"
-password = "postgres"
-# Maximum number of server connections that can be established for this user
-# The maximum number of connection from a single Pgcat process to any database in the cluster
-# is the sum of pool_size across all users.
-pool_size = 9
-
-# Maximum query duration. Dangerous, but protects against DBs that died in a non-obvious way.
-statement_timeout = 0
-
-[pools.sharded.users.1]
-username = "postgres"
-password = "postgres"
-pool_size = 21
-statement_timeout = 15000
-
-# Shard 0
-[pools.sharded.shards.0]
-# [ host, port, role ]
-servers = [
-    [ "postgres", 5432, "primary" ],
-    [ "postgres", 5432, "replica" ]
-]
-# Database name (e.g. "postgres")
-database = "postgres"
-
-[pools.sharded.shards.1]
-servers = [
-    [ "postgres", 5432, "primary" ],
-    [ "postgres", 5432, "replica" ],
-]
-database = "postgres"
-
-[pools.sharded.shards.2]
-servers = [
-    [ "postgres", 5432, "primary" ],
-    [ "postgres", 5432, "replica" ],
-]
-database = "postgres"
-
-
-[pools.simple_db]
-pool_mode = "session"
-default_role = "primary"
-query_parser_enabled = true
-primary_reads_enabled = true
-sharding_function = "pg_bigint_hash"
-
-[pools.simple_db.users.0]
-username = "postgres"
-password = "postgres"
-pool_size = 5
-statement_timeout = 0
-
-[pools.simple_db.shards.0]
-servers = [
-    [ "postgres", 5432, "primary" ],
-    [ "postgres", 5432, "replica" ]
-]
-database = "postgres"
--- a/pgcat.toml
+++ b/pgcat.toml
@@ -5,55 +5,78 @@
 #
 # General pooler settings
 [general]
+
 # What IP to run on, 0.0.0.0 means accessible from everywhere.
 host = "0.0.0.0"

 # Port to run on, same as PgBouncer used in this example.
 port = 6432

-# Whether to enable prometheus exporter or not.
-enable_prometheus_exporter = true
+# How many connections to allocate per server.
+pool_size = 15

-# Port at which prometheus exporter listens on.
-prometheus_exporter_port = 9930
-
-# How long to wait before aborting a server connection (ms).
-connect_timeout = 5000
-
-# How much time to give the health check query to return with a result (ms).
-healthcheck_timeout = 1000
-
-# How long to keep connection available for immediate re-use, without running a healthcheck query on it
-healthcheck_delay = 30000
-
-# How much time to give clients during shutdown before forcibly killing client connections (ms).
-shutdown_timeout = 60000
-
-# For how long to ban a server if it fails a health check (seconds).
-ban_time = 60 # seconds
-
-# Reload config automatically if it changes.
-autoreload = false
-
-# TLS
-# tls_certificate = "server.cert"
-# tls_private_key = "server.key"
-
-# Credentials to access the virtual administrative database (pgbouncer or pgcat)
-# Connecting to that database allows running commands like `SHOW POOLS`, `SHOW DATABASES`, etc..
-admin_username = "admin_user"
-admin_password = "admin_pass"
-
-# pool
-# configs are structured as pool.<pool_name>
-# the pool_name is what clients use as database name when connecting
-# For the example below a client can connect using "postgres://sharding_user:sharding_user@pgcat_host:pgcat_port/sharded_db"
-[pools.sharded_db]
 # Pool mode (see PgBouncer docs for more).
 # session: one server connection per connected client
 # transaction: one server connection per client transaction
 pool_mode = "transaction"

+# How long to wait before aborting a server connection (ms).
+connect_timeout = 5000
+
+# How much time to give `SELECT 1` health check query to return with a result (ms).
+healthcheck_timeout = 1000
+
+# For how long to ban a server if it fails a health check (seconds).
+ban_time = 60 # Seconds
+
+# Stats will be sent here
+statsd_address = "127.0.0.1:8125"
+
+#
+# User to use for authentication against the server.
+[user]
+name = "sharding_user"
+password = "sharding_user"
+
+
+#
+# Shards in the cluster
+[shards]
+
+# Shard 0
+[shards.0]
+
+# [ host, port, role ]
+servers = [
+    ["127.0.0.1", 5432, "primary"],
+    ["localhost", 5432, "replica"],
+    # [ "127.0.1.1", 5432, "replica" ],
+]
+# Database name (e.g. "postgres")
+database = "shard0"
+
+[shards.1]
+# [ host, port, role ]
+servers = [
+    ["127.0.0.1", 5432, "primary"],
+    ["localhost", 5432, "replica"],
+    # [ "127.0.1.1", 5432, "replica" ],
+]
+database = "shard1"
+
+[shards.2]
+# [ host, port, role ]
+servers = [
+    ["127.0.0.1", 5432, "primary"],
+    ["localhost", 5432, "replica"],
+    # [ "127.0.1.1", 5432, "replica" ],
+]
+database = "shard2"
+
+
+# Settings for our query routing layer.
+[query_router]
+
 # If the client doesn't specify, route traffic to
 # this role by default.
 #
@@ -62,15 +85,16 @@ pool_mode = "transaction"
 # primary: all queries go to the primary unless otherwise specified.
 default_role = "any"

+
 # Query parser. If enabled, we'll attempt to parse
 # every incoming query to determine if it's a read or a write.
 # If it's a read query, we'll direct it to a replica. Otherwise, if it's a write,
 # we'll direct it to the primary.
-query_parser_enabled = true
+query_parser_enabled = false

 # If the query parser is enabled and this setting is enabled, the primary will be part of the pool of databases used for
 # load balancing of read queries. Otherwise, the primary will only be used for write
-# queries. The primary can always be explicitly selected with our custom protocol.
+# queries. The primary can always be explicitely selected with our custom protocol.
 primary_reads_enabled = true

 # So what if you wanted to implement a different hashing function,
@@ -82,66 +106,3 @@ primary_reads_enabled = true
 # sha1: A hashing function based on SHA1
 #
 sharding_function = "pg_bigint_hash"
-
-# Credentials for users that may connect to this cluster
-[pools.sharded_db.users.0]
-username = "sharding_user"
-password = "sharding_user"
-# Maximum number of server connections that can be established for this user
-# The maximum number of connection from a single Pgcat process to any database in the cluster
-# is the sum of pool_size across all users.
-pool_size = 9
-
-# Maximum query duration. Dangerous, but protects against DBs that died in a non-obvious way.
-statement_timeout = 0
-
-[pools.sharded_db.users.1]
-username = "other_user"
-password = "other_user"
-pool_size = 21
-statement_timeout = 15000
-
-# Shard 0
-[pools.sharded_db.shards.0]
-# [ host, port, role ]
-servers = [
-    [ "127.0.0.1", 5432, "primary" ],
-    [ "localhost", 5432, "replica" ]
-]
-# Database name (e.g. "postgres")
-database = "shard0"
-
-[pools.sharded_db.shards.1]
-servers = [
-    [ "127.0.0.1", 5432, "primary" ],
-    [ "localhost", 5432, "replica" ],
-]
-database = "shard1"
-
-[pools.sharded_db.shards.2]
-servers = [
-    [ "127.0.0.1", 5432, "primary" ],
-    [ "localhost", 5432, "replica" ],
-]
-database = "shard2"
-
-
-[pools.simple_db]
-pool_mode = "session"
-default_role = "primary"
-query_parser_enabled = true
-primary_reads_enabled = true
-sharding_function = "pg_bigint_hash"
-
-[pools.simple_db.users.0]
-username = "simple_user"
-password = "simple_user"
-pool_size = 5
-statement_timeout = 0
-
-[pools.simple_db.shards.0]
-servers = [
-    [ "127.0.0.1", 5432, "primary" ],
-    [ "localhost", 5432, "replica" ]
-]
-database = "some_db"
--- a/src/admin.rs
+++ b/src/admin.rs
@@ -1,39 +1,21 @@
-/// Admin database.
 use bytes::{Buf, BufMut, BytesMut};
 use log::{info, trace};
-use std::collections::HashMap;
-use tokio::time::Instant;
+use tokio::net::tcp::OwnedWriteHalf;

-use crate::config::{get_config, reload_config, VERSION};
+use std::collections::HashMap;
+
+use crate::config::{get_config, parse};
 use crate::errors::Error;
 use crate::messages::*;
-use crate::pool::get_all_pools;
-use crate::stats::{
-    get_address_stats, get_client_stats, get_pool_stats, get_server_stats, ClientState, ServerState,
-};
-use crate::ClientServerMap;
+use crate::pool::ConnectionPool;
+use crate::stats::get_stats;

-pub fn generate_server_info_for_admin() -> BytesMut {
-    let mut server_info = BytesMut::new();
-
-    server_info.put(server_parameter_message("application_name", ""));
-    server_info.put(server_parameter_message("client_encoding", "UTF8"));
-    server_info.put(server_parameter_message("server_encoding", "UTF8"));
-    server_info.put(server_parameter_message("server_version", VERSION));
-    server_info.put(server_parameter_message("DateStyle", "ISO, MDY"));
-
-    return server_info;
-}
-
-/// Handle admin client.
-pub async fn handle_admin<T>(
-    stream: &mut T,
+/// Handle admin client
+pub async fn handle_admin(
+    stream: &mut OwnedWriteHalf,
    mut query: BytesMut,
-    client_server_map: ClientServerMap,
-) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+    pool: ConnectionPool,
+) -> Result<(), Error> {
    let code = query.get_u8() as char;

    if code != 'Q' {
@@ -47,95 +29,59 @@ where

    trace!("Admin query: {}", query);

-    let query_parts: Vec<&str> = query.trim_end_matches(';').split_whitespace().collect();
-
-    match query_parts[0] {
-        "RELOAD" => {
-            trace!("RELOAD");
-            reload(stream, client_server_map).await
-        }
-        "SET" => {
-            trace!("SET");
-            ignore_set(stream).await
-        }
-        "SHOW" => match query_parts[1] {
-            "CONFIG" => {
-                trace!("SHOW CONFIG");
-                show_config(stream).await
-            }
-            "DATABASES" => {
-                trace!("SHOW DATABASES");
-                show_databases(stream).await
-            }
-            "LISTS" => {
-                trace!("SHOW LISTS");
-                show_lists(stream).await
-            }
-            "POOLS" => {
-                trace!("SHOW POOLS");
-                show_pools(stream).await
-            }
-            "CLIENTS" => {
-                trace!("SHOW CLIENTS");
-                show_clients(stream).await
-            }
-            "SERVERS" => {
-                trace!("SHOW SERVERS");
-                show_servers(stream).await
-            }
-            "STATS" => {
-                trace!("SHOW STATS");
-                show_stats(stream).await
-            }
-            "VERSION" => {
-                trace!("SHOW VERSION");
-                show_version(stream).await
-            }
-            _ => error_response(stream, "Unsupported SHOW query against the admin database").await,
-        },
-        _ => error_response(stream, "Unsupported query against the admin database").await,
+    if query.starts_with("SHOW STATS") {
+        trace!("SHOW STATS");
+        show_stats(stream).await
+    } else if query.starts_with("RELOAD") {
+        trace!("RELOAD");
+        reload(stream).await
+    } else if query.starts_with("SHOW CONFIG") {
+        trace!("SHOW CONFIG");
+        show_config(stream).await
+    } else if query.starts_with("SHOW DATABASES") {
+        trace!("SHOW DATABASES");
+        show_databases(stream, &pool).await
+    } else if query.starts_with("SHOW POOLS") {
+        trace!("SHOW POOLS");
+        show_pools(stream, &pool).await
+    } else if query.starts_with("SHOW LISTS") {
+        trace!("SHOW LISTS");
+        show_lists(stream, &pool).await
+    } else if query.starts_with("SHOW VERSION") {
+        trace!("SHOW VERSION");
+        show_version(stream).await
+    } else if query.starts_with("SET ") {
+        trace!("SET");
+        ignore_set(stream).await
+    } else {
+        error_response(stream, "Unsupported query against the admin database").await
    }
 }

-/// Column-oriented statistics.
-async fn show_lists<T>(stream: &mut T) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    let client_stats = get_client_stats();
-    let server_stats = get_server_stats();
+/// SHOW LISTS
+async fn show_lists(stream: &mut OwnedWriteHalf, pool: &ConnectionPool) -> Result<(), Error> {
+    let stats = get_stats();

    let columns = vec![("list", DataType::Text), ("items", DataType::Int4)];

-    let mut users = 1;
-    let mut databases = 1;
-    for (_, pool) in get_all_pools() {
-        databases += pool.databases();
-        users += 1; // One user per pool
-    }
    let mut res = BytesMut::new();
    res.put(row_description(&columns));
    res.put(data_row(&vec![
        "databases".to_string(),
-        databases.to_string(),
+        (pool.databases() + 1).to_string(), // see comment below
    ]));
-    res.put(data_row(&vec!["users".to_string(), users.to_string()]));
-    res.put(data_row(&vec!["pools".to_string(), databases.to_string()]));
+    res.put(data_row(&vec!["users".to_string(), "1".to_string()]));
+    res.put(data_row(&vec![
+        "pools".to_string(),
+        (pool.databases() + 1).to_string(), // +1 for the pgbouncer admin db pool which isn't real
+    ])); // but admin tools that work with pgbouncer want this
    res.put(data_row(&vec![
        "free_clients".to_string(),
-        client_stats
-            .keys()
-            .filter(|client_id| client_stats.get(client_id).unwrap().state == ClientState::Idle)
-            .count()
-            .to_string(),
+        stats["cl_idle"].to_string(),
    ]));
    res.put(data_row(&vec![
        "used_clients".to_string(),
-        client_stats
-            .keys()
-            .filter(|client_id| client_stats.get(client_id).unwrap().state == ClientState::Active)
-            .count()
-            .to_string(),
+        stats["cl_active"].to_string(),
    ]));
    res.put(data_row(&vec![
        "login_clients".to_string(),
@@ -143,19 +89,11 @@ where
    ]));
    res.put(data_row(&vec![
        "free_servers".to_string(),
-        server_stats
-            .keys()
-            .filter(|server_id| server_stats.get(server_id).unwrap().state == ServerState::Idle)
-            .count()
-            .to_string(),
+        stats["sv_idle"].to_string(),
    ]));
    res.put(data_row(&vec![
        "used_servers".to_string(),
-        server_stats
-            .keys()
-            .filter(|server_id| server_stats.get(server_id).unwrap().state == ServerState::Active)
-            .count()
-            .to_string(),
+        stats["sv_active"].to_string(),
    ]));
    res.put(data_row(&vec!["dns_names".to_string(), "0".to_string()]));
    res.put(data_row(&vec!["dns_zones".to_string(), "0".to_string()]));
@@ -171,15 +109,12 @@ where
    write_all_half(stream, res).await
 }

-/// Show PgCat version.
-async fn show_version<T>(stream: &mut T) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+/// SHOW VERSION
+async fn show_version(stream: &mut OwnedWriteHalf) -> Result<(), Error> {
    let mut res = BytesMut::new();

    res.put(row_description(&vec![("version", DataType::Text)]));
-    res.put(data_row(&vec![format!("PgCat {}", VERSION).to_string()]));
+    res.put(data_row(&vec!["PgCat 0.1.0".to_string()]));
    res.put(command_complete("SHOW"));

    res.put_u8(b'Z');
@@ -189,18 +124,17 @@ where
    write_all_half(stream, res).await
 }

-/// Show utilization of connection pools for each shard and replicas.
-async fn show_pools<T>(stream: &mut T) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    let all_pool_stats = get_pool_stats();
+/// SHOW POOLS
+async fn show_pools(stream: &mut OwnedWriteHalf, _pool: &ConnectionPool) -> Result<(), Error> {
+    let stats = get_stats();
+    let config = {
+        let guard = get_config();
+        &*guard.clone()
+    };

    let columns = vec![
        ("database", DataType::Text),
        ("user", DataType::Text),
-        ("pool_mode", DataType::Text),
-        ("cl_idle", DataType::Numeric),
        ("cl_active", DataType::Numeric),
        ("cl_waiting", DataType::Numeric),
        ("cl_cancel_req", DataType::Numeric),
@@ -211,38 +145,24 @@ where
        ("sv_login", DataType::Numeric),
        ("maxwait", DataType::Numeric),
        ("maxwait_us", DataType::Numeric),
+        ("pool_mode", DataType::Text),
    ];

    let mut res = BytesMut::new();
    res.put(row_description(&columns));
-    for (user_pool, pool) in get_all_pools() {
-        let def = HashMap::default();
-        let pool_stats = all_pool_stats
-            .get(&(user_pool.db.clone(), user_pool.user.clone()))
-            .unwrap_or(&def);

-        let pool_config = &pool.settings;
-        let mut row = vec![
-            user_pool.db.clone(),
-            user_pool.user.clone(),
-            pool_config.pool_mode.to_string(),
-        ];
-        for column in &columns[3..columns.len()] {
-            let value = match column.0 {
-                "maxwait" => (pool_stats.get("maxwait_us").unwrap_or(&0) / 1_000_000).to_string(),
-                "maxwait_us" => {
-                    (pool_stats.get("maxwait_us").unwrap_or(&0) % 1_000_000).to_string()
-                }
-                _other_values => pool_stats.get(column.0).unwrap_or(&0).to_string(),
-            };
-            row.push(value);
-        }
-        res.put(data_row(&row));
+    let mut row = vec![String::from("all"), config.user.name.clone()];
+
+    for column in &columns[2..columns.len() - 1] {
+        let value = stats.get(column.0).unwrap_or(&0).to_string();
+        row.push(value);
    }

+    row.push(config.general.pool_mode.to_string());
+
+    res.put(data_row(&row));
    res.put(command_complete("SHOW"));

-    // ReadyForQuery
    res.put_u8(b'Z');
    res.put_i32(5);
    res.put_u8(b'I');
@@ -250,11 +170,12 @@ where
    write_all_half(stream, res).await
 }

-/// Show shards and replicas.
-async fn show_databases<T>(stream: &mut T) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+/// SHOW DATABASES
+async fn show_databases(stream: &mut OwnedWriteHalf, pool: &ConnectionPool) -> Result<(), Error> {
+    let guard = get_config();
+    let config = &*guard.clone();
+    drop(guard);
+
    // Columns
    let columns = vec![
        ("name", DataType::Text),
@@ -274,39 +195,34 @@ where

    let mut res = BytesMut::new();

+    // RowDescription
    res.put(row_description(&columns));

-    for (_, pool) in get_all_pools() {
-        let pool_config = pool.settings.clone();
-        for shard in 0..pool.shards() {
-            let database_name = &pool.address(shard, 0).database;
-            for server in 0..pool.servers(shard) {
-                let address = pool.address(shard, server);
-                let pool_state = pool.pool_state(shard, server);
-                let banned = pool.is_banned(address, Some(address.role));
+    for shard in 0..pool.shards() {
+        let database_name = &config.shards[&shard.to_string()].database;

-                res.put(data_row(&vec![
-                    address.name(),                         // name
-                    address.host.to_string(),               // host
-                    address.port.to_string(),               // port
-                    database_name.to_string(),              // database
-                    pool_config.user.username.to_string(),  // force_user
-                    pool_config.user.pool_size.to_string(), // pool_size
-                    "0".to_string(),                        // min_pool_size
-                    "0".to_string(),                        // reserve_pool
-                    pool_config.pool_mode.to_string(),      // pool_mode
-                    pool_config.user.pool_size.to_string(), // max_connections
-                    pool_state.connections.to_string(),     // current_connections
-                    "0".to_string(),                        // paused
-                    match banned {
-                        // disabled
-                        true => "1".to_string(),
-                        false => "0".to_string(),
-                    },
-                ]));
-            }
+        for server in 0..pool.servers(shard) {
+            let address = pool.address(shard, server);
+            let pool_state = pool.pool_state(shard, server);
+
+            res.put(data_row(&vec![
+                address.name(),                       // name
+                address.host.to_string(),             // host
+                address.port.to_string(),             // port
+                database_name.to_string(),            // database
+                config.user.name.to_string(),         // force_user
+                config.general.pool_size.to_string(), // pool_size
+                "0".to_string(),                      // min_pool_size
+                "0".to_string(),                      // reserve_pool
+                config.general.pool_mode.to_string(), // pool_mode
+                config.general.pool_size.to_string(), // max_connections
+                pool_state.connections.to_string(),   // current_connections
+                "0".to_string(),                      // paused
+                "0".to_string(),                      // disabled
+            ]));
        }
    }
+
    res.put(command_complete("SHOW"));

    // ReadyForQuery
@@ -319,26 +235,26 @@ where

 /// Ignore any SET commands the client sends.
 /// This is common initialization done by ORMs.
-async fn ignore_set<T>(stream: &mut T) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+async fn ignore_set(stream: &mut OwnedWriteHalf) -> Result<(), Error> {
    custom_protocol_response_ok(stream, "SET").await
 }

-/// Reload the configuration file without restarting the process.
-async fn reload<T>(stream: &mut T, client_server_map: ClientServerMap) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+/// RELOAD
+async fn reload(stream: &mut OwnedWriteHalf) -> Result<(), Error> {
    info!("Reloading config");

-    reload_config(client_server_map).await?;
+    let config = get_config();
+    let path = config.path.clone().unwrap();

-    get_config().show();
+    parse(&path).await?;
+
+    let config = get_config();
+
+    config.show();

    let mut res = BytesMut::new();

+    // CommandComplete
    res.put(command_complete("RELOAD"));

    // ReadyForQuery
@@ -349,15 +265,13 @@ where
    write_all_half(stream, res).await
 }

-/// Shows current configuration.
-async fn show_config<T>(stream: &mut T) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    let config = &get_config();
+async fn show_config(stream: &mut OwnedWriteHalf) -> Result<(), Error> {
+    let guard = get_config();
+    let config = &*guard.clone();
    let config: HashMap<String, String> = config.into();
+    drop(guard);

-    // Configs that cannot be changed without restarting.
+    // Configs that cannot be changed dynamically.
    let immutables = ["host", "port", "connect_timeout"];

    // Columns
@@ -387,7 +301,6 @@ where

    res.put(command_complete("SHOW"));

-    // ReadyForQuery
    res.put_u8(b'Z');
    res.put_i32(5);
    res.put_u8(b'I');
@@ -395,15 +308,10 @@ where
    write_all_half(stream, res).await
 }

-/// Show shard and replicas statistics.
-async fn show_stats<T>(stream: &mut T) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+/// SHOW STATS
+async fn show_stats(stream: &mut OwnedWriteHalf) -> Result<(), Error> {
    let columns = vec![
-        ("instance", DataType::Text),
        ("database", DataType::Text),
-        ("user", DataType::Text),
        ("total_xact_count", DataType::Numeric),
        ("total_query_count", DataType::Numeric),
        ("total_received", DataType::Numeric),
@@ -411,147 +319,30 @@ where
        ("total_xact_time", DataType::Numeric),
        ("total_query_time", DataType::Numeric),
        ("total_wait_time", DataType::Numeric),
-        ("total_errors", DataType::Numeric),
        ("avg_xact_count", DataType::Numeric),
        ("avg_query_count", DataType::Numeric),
        ("avg_recv", DataType::Numeric),
        ("avg_sent", DataType::Numeric),
-        ("avg_errors", DataType::Numeric),
        ("avg_xact_time", DataType::Numeric),
        ("avg_query_time", DataType::Numeric),
        ("avg_wait_time", DataType::Numeric),
    ];

-    let all_stats = get_address_stats();
+    let stats = get_stats();
    let mut res = BytesMut::new();
    res.put(row_description(&columns));

-    for (user_pool, pool) in get_all_pools() {
-        for shard in 0..pool.shards() {
-            for server in 0..pool.servers(shard) {
-                let address = pool.address(shard, server);
-                let stats = match all_stats.get(&address.id) {
-                    Some(stats) => stats.clone(),
-                    None => HashMap::new(),
-                };
-
-                let mut row = vec![address.name(), user_pool.db.clone(), user_pool.user.clone()];
-                for column in &columns[3..] {
-                    row.push(stats.get(column.0).unwrap_or(&0).to_string());
-                }
-
-                res.put(data_row(&row));
-            }
-        }
-    }
-
-    res.put(command_complete("SHOW"));
-
-    // ReadyForQuery
-    res.put_u8(b'Z');
-    res.put_i32(5);
-    res.put_u8(b'I');
-
-    write_all_half(stream, res).await
-}
-
-/// Show currently connected clients
-async fn show_clients<T>(stream: &mut T) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    let columns = vec![
-        ("client_id", DataType::Text),
-        ("database", DataType::Text),
-        ("user", DataType::Text),
-        ("application_name", DataType::Text),
-        ("state", DataType::Text),
-        ("transaction_count", DataType::Numeric),
-        ("query_count", DataType::Numeric),
-        ("error_count", DataType::Numeric),
-        ("age_seconds", DataType::Numeric),
+    let mut row = vec![
+        String::from("all"), // TODO: per-database stats,
    ];

-    let new_map = get_client_stats();
-    let mut res = BytesMut::new();
-    res.put(row_description(&columns));
-
-    for (_, client) in new_map {
-        let row = vec![
-            format!("{:#010X}", client.client_id),
-            client.pool_name,
-            client.username,
-            client.application_name.clone(),
-            client.state.to_string(),
-            client.transaction_count.to_string(),
-            client.query_count.to_string(),
-            client.error_count.to_string(),
-            Instant::now()
-                .duration_since(client.connect_time)
-                .as_secs()
-                .to_string(),
-        ];
-
-        res.put(data_row(&row));
+    for column in &columns[1..] {
+        row.push(stats.get(column.0).unwrap_or(&0).to_string());
    }

+    res.put(data_row(&row));
    res.put(command_complete("SHOW"));

-    // ReadyForQuery
-    res.put_u8(b'Z');
-    res.put_i32(5);
-    res.put_u8(b'I');
-
-    write_all_half(stream, res).await
-}
-
-/// Show currently connected servers
-async fn show_servers<T>(stream: &mut T) -> Result<(), Error>
-where
-    T: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    let columns = vec![
-        ("server_id", DataType::Text),
-        ("database_name", DataType::Text),
-        ("user", DataType::Text),
-        ("address_id", DataType::Text),
-        ("application_name", DataType::Text),
-        ("state", DataType::Text),
-        ("transaction_count", DataType::Numeric),
-        ("query_count", DataType::Numeric),
-        ("bytes_sent", DataType::Numeric),
-        ("bytes_received", DataType::Numeric),
-        ("age_seconds", DataType::Numeric),
-    ];
-
-    let new_map = get_server_stats();
-    let mut res = BytesMut::new();
-    res.put(row_description(&columns));
-
-    for (_, server) in new_map {
-        let row = vec![
-            format!("{:#010X}", server.server_id),
-            server.pool_name,
-            server.username,
-            server.address_name,
-            server.application_name,
-            server.state.to_string(),
-            server.transaction_count.to_string(),
-            server.query_count.to_string(),
-            server.bytes_sent.to_string(),
-            server.bytes_received.to_string(),
-            Instant::now()
-                .duration_since(server.connect_time)
-                .as_secs()
-                .to_string(),
-        ];
-
-        res.put(data_row(&row));
-    }
-
-    res.put(command_complete("SHOW"));
-
-    // ReadyForQuery
    res.put_u8(b'Z');
    res.put_i32(5);
    res.put_u8(b'I');
--- a/src/client.rs
+++ b/src/client.rs
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,32 +1,21 @@
-/// Parse the configuration file.
-use arc_swap::ArcSwap;
+use arc_swap::{ArcSwap, Guard};
 use log::{error, info};
 use once_cell::sync::Lazy;
-use serde_derive::{Deserialize, Serialize};
-use std::collections::{BTreeMap, HashMap, HashSet};
-use std::hash::Hash;
-use std::path::Path;
-use std::sync::Arc;
+use serde_derive::Deserialize;
 use tokio::fs::File;
 use tokio::io::AsyncReadExt;
 use toml;

+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
 use crate::errors::Error;
-use crate::pool::{ClientServerMap, ConnectionPool};
-use crate::sharding::ShardingFunction;
-use crate::tls::{load_certs, load_keys};

-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
-
-/// Globally available configuration.
 static CONFIG: Lazy<ArcSwap<Config>> = Lazy::new(|| ArcSwap::from_pointee(Config::default()));

-/// Server role: primary or replica.
-#[derive(Clone, PartialEq, Serialize, Deserialize, Hash, std::cmp::Eq, Debug, Copy)]
+#[derive(Clone, PartialEq, Deserialize, Hash, std::cmp::Eq, Debug, Copy)]
 pub enum Role {
-    #[serde(alias = "primary", alias = "Primary")]
    Primary,
-    #[serde(alias = "replica", alias = "Replica")]
    Replica,
 }

@@ -57,425 +46,146 @@ impl PartialEq<Role> for Option<Role> {
    }
 }

-/// Address identifying a PostgreSQL server uniquely.
 #[derive(Clone, PartialEq, Hash, std::cmp::Eq, Debug)]
 pub struct Address {
-    /// Unique ID per addressable Postgres server.
-    pub id: usize,
-
-    /// Server host.
    pub host: String,
-
-    /// Server port.
-    pub port: u16,
-
-    /// Shard number of this Postgres server.
+    pub port: String,
    pub shard: usize,
-
-    /// The name of the Postgres database.
-    pub database: String,
-
-    /// Server role: replica, primary.
    pub role: Role,
-
-    /// If it's a replica, number it for reference and failover.
    pub replica_number: usize,
-
-    /// Position of the server in the pool for failover.
-    pub address_index: usize,
-
-    /// The name of the user configured to use this pool.
-    pub username: String,
-
-    /// The name of this pool (i.e. database name visible to the client).
-    pub pool_name: String,
 }

 impl Default for Address {
    fn default() -> Address {
        Address {
-            id: 0,
            host: String::from("127.0.0.1"),
-            port: 5432,
+            port: String::from("5432"),
            shard: 0,
-            address_index: 0,
            replica_number: 0,
-            database: String::from("database"),
            role: Role::Replica,
-            username: String::from("username"),
-            pool_name: String::from("pool_name"),
        }
    }
 }

 impl Address {
-    /// Address name (aka database) used in `SHOW STATS`, `SHOW DATABASES`, and `SHOW POOLS`.
    pub fn name(&self) -> String {
        match self.role {
-            Role::Primary => format!("{}_shard_{}_primary", self.pool_name, self.shard),
+            Role::Primary => format!("shard_{}_primary", self.shard),

-            Role::Replica => format!(
-                "{}_shard_{}_replica_{}",
-                self.pool_name, self.shard, self.replica_number
-            ),
+            Role::Replica => format!("shard_{}_replica_{}", self.shard, self.replica_number),
        }
    }
 }

-/// PostgreSQL user.
-#[derive(Clone, PartialEq, Hash, Eq, Serialize, Deserialize, Debug)]
+#[derive(Clone, PartialEq, Hash, std::cmp::Eq, Deserialize, Debug)]
 pub struct User {
-    pub username: String,
+    pub name: String,
    pub password: String,
-    pub pool_size: u32,
-    #[serde(default)] // 0
-    pub statement_timeout: u64,
 }

 impl Default for User {
    fn default() -> User {
        User {
-            username: String::from("postgres"),
+            name: String::from("postgres"),
            password: String::new(),
-            pool_size: 15,
-            statement_timeout: 0,
        }
    }
 }

-/// General configuration.
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+#[derive(Deserialize, Debug, Clone)]
 pub struct General {
-    #[serde(default = "General::default_host")]
    pub host: String,
-
-    #[serde(default = "General::default_port")]
    pub port: i16,
-
-    pub enable_prometheus_exporter: Option<bool>,
-    pub prometheus_exporter_port: i16,
-
-    #[serde(default = "General::default_connect_timeout")]
+    pub pool_size: u32,
+    pub pool_mode: String,
    pub connect_timeout: u64,
-
-    #[serde(default = "General::default_shutdown_timeout")]
-    pub shutdown_timeout: u64,
-
-    #[serde(default = "General::default_healthcheck_timeout")]
    pub healthcheck_timeout: u64,
-
-    #[serde(default = "General::default_healthcheck_delay")]
-    pub healthcheck_delay: u64,
-
-    #[serde(default = "General::default_ban_time")]
    pub ban_time: i64,
-
-    #[serde(default)] // False
-    pub autoreload: bool,
-
-    pub tls_certificate: Option<String>,
-    pub tls_private_key: Option<String>,
-    pub admin_username: String,
-    pub admin_password: String,
-}
-
-impl General {
-    pub fn default_host() -> String {
-        "0.0.0.0".into()
-    }
-
-    pub fn default_port() -> i16 {
-        5432
-    }
-
-    pub fn default_connect_timeout() -> u64 {
-        1000
-    }
-
-    pub fn default_shutdown_timeout() -> u64 {
-        60000
-    }
-
-    pub fn default_healthcheck_timeout() -> u64 {
-        1000
-    }
-
-    pub fn default_healthcheck_delay() -> u64 {
-        30000
-    }
-
-    pub fn default_ban_time() -> i64 {
-        60
-    }
+    pub statsd_address: String,
 }

 impl Default for General {
    fn default() -> General {
        General {
-            host: Self::default_host(),
-            port: Self::default_port(),
-            enable_prometheus_exporter: Some(false),
-            prometheus_exporter_port: 9930,
-            connect_timeout: General::default_connect_timeout(),
-            shutdown_timeout: Self::default_shutdown_timeout(),
-            healthcheck_timeout: Self::default_healthcheck_timeout(),
-            healthcheck_delay: Self::default_healthcheck_delay(),
-            ban_time: Self::default_ban_time(),
-            autoreload: false,
-            tls_certificate: None,
-            tls_private_key: None,
-            admin_username: String::from("admin"),
-            admin_password: String::from("admin"),
+            host: String::from("localhost"),
+            port: 5432,
+            pool_size: 15,
+            pool_mode: String::from("transaction"),
+            connect_timeout: 5000,
+            healthcheck_timeout: 1000,
+            ban_time: 60,
+            statsd_address: String::from("127.0.0.1:8125"),
        }
    }
 }

-/// Pool mode:
-/// - transaction: server serves one transaction,
-/// - session: server is attached to the client.
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Copy, Hash)]
-pub enum PoolMode {
-    #[serde(alias = "transaction", alias = "Transaction")]
-    Transaction,
-
-    #[serde(alias = "session", alias = "Session")]
-    Session,
-}
-
-impl ToString for PoolMode {
-    fn to_string(&self) -> String {
-        match *self {
-            PoolMode::Transaction => "transaction".to_string(),
-            PoolMode::Session => "session".to_string(),
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Pool {
-    #[serde(default = "Pool::default_pool_mode")]
-    pub pool_mode: PoolMode,
-
-    pub default_role: String,
-
-    #[serde(default)] // False
-    pub query_parser_enabled: bool,
-
-    #[serde(default)] // False
-    pub primary_reads_enabled: bool,
-
-    pub connect_timeout: Option<u64>,
-
-    pub sharding_function: ShardingFunction,
-    pub shards: BTreeMap<String, Shard>,
-    pub users: BTreeMap<String, User>,
-}
-
-impl Pool {
-    pub fn default_pool_mode() -> PoolMode {
-        PoolMode::Transaction
-    }
-
-    pub fn validate(&self) -> Result<(), Error> {
-        match self.default_role.as_ref() {
-            "any" => (),
-            "primary" => (),
-            "replica" => (),
-            other => {
-                error!(
-                    "Query router default_role must be 'primary', 'replica', or 'any', got: '{}'",
-                    other
-                );
-                return Err(Error::BadConfig);
-            }
-        };
-
-        for (shard_idx, shard) in &self.shards {
-            match shard_idx.parse::<usize>() {
-                Ok(_) => (),
-                Err(_) => {
-                    error!(
-                        "Shard '{}' is not a valid number, shards must be numbered starting at 0",
-                        shard_idx
-                    );
-                    return Err(Error::BadConfig);
-                }
-            };
-            shard.validate()?;
-        }
-
-        Ok(())
-    }
-}
-
-impl Default for Pool {
-    fn default() -> Pool {
-        Pool {
-            pool_mode: Self::default_pool_mode(),
-            shards: BTreeMap::from([(String::from("1"), Shard::default())]),
-            users: BTreeMap::default(),
-            default_role: String::from("any"),
-            query_parser_enabled: false,
-            primary_reads_enabled: false,
-            sharding_function: ShardingFunction::PgBigintHash,
-            connect_timeout: None,
-        }
-    }
-}
-
-#[derive(Clone, PartialEq, Serialize, Deserialize, Debug, Hash, Eq)]
-pub struct ServerConfig {
-    pub host: String,
-    pub port: u16,
-    pub role: Role,
-}
-
-/// Shard configuration.
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Hash, Eq)]
+#[derive(Deserialize, Debug, Clone)]
 pub struct Shard {
+    pub servers: Vec<(String, u16, String)>,
    pub database: String,
-    pub servers: Vec<ServerConfig>,
-}
-
-impl Shard {
-    pub fn validate(&self) -> Result<(), Error> {
-        // We use addresses as unique identifiers,
-        // let's make sure they are unique in the config as well.
-        let mut dup_check = HashSet::new();
-        let mut primary_count = 0;
-
-        if self.servers.len() == 0 {
-            error!("Shard {} has no servers configured", self.database);
-            return Err(Error::BadConfig);
-        }
-
-        for server in &self.servers {
-            dup_check.insert(server);
-
-            // Check that we define only zero or one primary.
-            match server.role {
-                Role::Primary => primary_count += 1,
-                _ => (),
-            };
-        }
-
-        if primary_count > 1 {
-            error!(
-                "Shard {} has more than on primary configured",
-                self.database
-            );
-            return Err(Error::BadConfig);
-        }
-
-        if dup_check.len() != self.servers.len() {
-            error!("Shard {} contains duplicate server configs", self.database);
-            return Err(Error::BadConfig);
-        }
-
-        Ok(())
-    }
 }

 impl Default for Shard {
    fn default() -> Shard {
        Shard {
-            servers: vec![ServerConfig {
-                host: String::from("localhost"),
-                port: 5432,
-                role: Role::Primary,
-            }],
+            servers: vec![(String::from("localhost"), 5432, String::from("primary"))],
            database: String::from("postgres"),
        }
    }
 }

-/// Configuration wrapper.
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
-pub struct Config {
-    // Serializer maintains the order of fields in the struct
-    // so we should always put simple fields before nested fields
-    // in all serializable structs to avoid ValueAfterTable errors
-    // These errors occur when the toml serializer is about to produce
-    // ambiguous toml structure like the one below
-    // [main]
-    // field1_under_main = 1
-    // field2_under_main = 2
-    // [main.subconf]
-    // field1_under_subconf = 1
-    // field3_under_main = 3 # This field will be interpreted as being under subconf and not under main
-    #[serde(default = "Config::default_path")]
-    pub path: String,
-
-    pub general: General,
-    pub pools: HashMap<String, Pool>,
+#[derive(Deserialize, Debug, Clone)]
+pub struct QueryRouter {
+    pub default_role: String,
+    pub query_parser_enabled: bool,
+    pub primary_reads_enabled: bool,
+    pub sharding_function: String,
 }

-impl Config {
-    pub fn default_path() -> String {
-        String::from("pgcat.toml")
+impl Default for QueryRouter {
+    fn default() -> QueryRouter {
+        QueryRouter {
+            default_role: String::from("any"),
+            query_parser_enabled: false,
+            primary_reads_enabled: true,
+            sharding_function: "pg_bigint_hash".to_string(),
+        }
    }
 }

+#[derive(Deserialize, Debug, Clone)]
+pub struct Config {
+    pub path: Option<String>,
+    pub general: General,
+    pub user: User,
+    pub shards: HashMap<String, Shard>,
+    pub query_router: QueryRouter,
+}
+
 impl Default for Config {
    fn default() -> Config {
        Config {
-            path: Self::default_path(),
+            path: Some(String::from("pgcat.toml")),
            general: General::default(),
-            pools: HashMap::default(),
+            user: User::default(),
+            shards: HashMap::from([(String::from("1"), Shard::default())]),
+            query_router: QueryRouter::default(),
        }
    }
 }

 impl From<&Config> for std::collections::HashMap<String, String> {
    fn from(config: &Config) -> HashMap<String, String> {
-        let mut r: Vec<(String, String)> = config
-            .pools
-            .iter()
-            .flat_map(|(pool_name, pool)| {
-                [
-                    (
-                        format!("pools.{}.pool_mode", pool_name),
-                        pool.pool_mode.to_string(),
-                    ),
-                    (
-                        format!("pools.{}.primary_reads_enabled", pool_name),
-                        pool.primary_reads_enabled.to_string(),
-                    ),
-                    (
-                        format!("pools.{}.query_parser_enabled", pool_name),
-                        pool.query_parser_enabled.to_string(),
-                    ),
-                    (
-                        format!("pools.{}.default_role", pool_name),
-                        pool.default_role.clone(),
-                    ),
-                    (
-                        format!("pools.{}.sharding_function", pool_name),
-                        pool.sharding_function.to_string(),
-                    ),
-                    (
-                        format!("pools.{:?}.shard_count", pool_name),
-                        pool.shards.len().to_string(),
-                    ),
-                    (
-                        format!("pools.{:?}.users", pool_name),
-                        pool.users
-                            .iter()
-                            .map(|(_username, user)| &user.username)
-                            .cloned()
-                            .collect::<Vec<String>>()
-                            .join(", "),
-                    ),
-                ]
-            })
-            .collect();
-
-        let mut static_settings = vec![
+        HashMap::from([
            ("host".to_string(), config.general.host.to_string()),
            ("port".to_string(), config.general.port.to_string()),
            (
-                "prometheus_exporter_port".to_string(),
-                config.general.prometheus_exporter_port.to_string(),
+                "pool_size".to_string(),
+                config.general.pool_size.to_string(),
+            ),
+            (
+                "pool_mode".to_string(),
+                config.general.pool_mode.to_string(),
            ),
            (
                "connect_timeout".to_string(),
@@ -485,166 +195,51 @@ impl From<&Config> for std::collections::HashMap<String, String> {
                "healthcheck_timeout".to_string(),
                config.general.healthcheck_timeout.to_string(),
            ),
-            (
-                "shutdown_timeout".to_string(),
-                config.general.shutdown_timeout.to_string(),
-            ),
-            (
-                "healthcheck_delay".to_string(),
-                config.general.healthcheck_delay.to_string(),
-            ),
            ("ban_time".to_string(), config.general.ban_time.to_string()),
-        ];
-
-        r.append(&mut static_settings);
-        return r.iter().cloned().collect();
+            (
+                "statsd_address".to_string(),
+                config.general.statsd_address.to_string(),
+            ),
+            (
+                "default_role".to_string(),
+                config.query_router.default_role.to_string(),
+            ),
+            (
+                "query_parser_enabled".to_string(),
+                config.query_router.query_parser_enabled.to_string(),
+            ),
+            (
+                "primary_reads_enabled".to_string(),
+                config.query_router.primary_reads_enabled.to_string(),
+            ),
+            (
+                "sharding_function".to_string(),
+                config.query_router.sharding_function.to_string(),
+            ),
+        ])
    }
 }

 impl Config {
-    /// Print current configuration.
    pub fn show(&self) {
+        info!("Pool size: {}", self.general.pool_size);
+        info!("Pool mode: {}", self.general.pool_mode);
        info!("Ban time: {}s", self.general.ban_time);
        info!(
            "Healthcheck timeout: {}ms",
            self.general.healthcheck_timeout
        );
        info!("Connection timeout: {}ms", self.general.connect_timeout);
-        info!("Shutdown timeout: {}ms", self.general.shutdown_timeout);
-        info!("Healthcheck delay: {}ms", self.general.healthcheck_delay);
-        match self.general.tls_certificate.clone() {
-            Some(tls_certificate) => {
-                info!("TLS certificate: {}", tls_certificate);
-
-                match self.general.tls_private_key.clone() {
-                    Some(tls_private_key) => {
-                        info!("TLS private key: {}", tls_private_key);
-                        info!("TLS support is enabled");
-                    }
-
-                    None => (),
-                }
-            }
-
-            None => {
-                info!("TLS support is disabled");
-            }
-        };
-
-        for (pool_name, pool_config) in &self.pools {
-            // TODO: Make this output prettier (maybe a table?)
-            info!(
-                "[pool: {}] Maximum user connections: {}",
-                pool_name,
-                pool_config
-                    .users
-                    .iter()
-                    .map(|(_, user_cfg)| user_cfg.pool_size)
-                    .sum::<u32>()
-                    .to_string()
-            );
-            info!(
-                "[pool: {}] Pool mode: {:?}",
-                pool_name, pool_config.pool_mode
-            );
-            let connect_timeout = match pool_config.connect_timeout {
-                Some(connect_timeout) => connect_timeout,
-                None => self.general.connect_timeout,
-            };
-            info!(
-                "[pool: {}] Connection timeout: {}ms",
-                pool_name, connect_timeout
-            );
-            info!(
-                "[pool: {}] Sharding function: {}",
-                pool_name,
-                pool_config.sharding_function.to_string()
-            );
-            info!(
-                "[pool: {}] Primary reads: {}",
-                pool_name, pool_config.primary_reads_enabled
-            );
-            info!(
-                "[pool: {}] Query router: {}",
-                pool_name, pool_config.query_parser_enabled
-            );
-            info!(
-                "[pool: {}] Number of shards: {}",
-                pool_name,
-                pool_config.shards.len()
-            );
-            info!(
-                "[pool: {}] Number of users: {}",
-                pool_name,
-                pool_config.users.len()
-            );
-
-            for user in &pool_config.users {
-                info!(
-                    "[pool: {}][user: {}] Pool size: {}",
-                    pool_name, user.1.username, user.1.pool_size,
-                );
-                info!(
-                    "[pool: {}][user: {}] Statement timeout: {}",
-                    pool_name, user.1.username, user.1.statement_timeout
-                )
-            }
-        }
-    }
-
-    pub fn validate(&mut self) -> Result<(), Error> {
-        // Validate TLS!
-        match self.general.tls_certificate.clone() {
-            Some(tls_certificate) => {
-                match load_certs(&Path::new(&tls_certificate)) {
-                    Ok(_) => {
-                        // Cert is okay, but what about the private key?
-                        match self.general.tls_private_key.clone() {
-                            Some(tls_private_key) => {
-                                match load_keys(&Path::new(&tls_private_key)) {
-                                    Ok(_) => (),
-                                    Err(err) => {
-                                        error!(
-                                            "tls_private_key is incorrectly configured: {:?}",
-                                            err
-                                        );
-                                        return Err(Error::BadConfig);
-                                    }
-                                }
-                            }
-
-                            None => {
-                                error!("tls_certificate is set, but the tls_private_key is not");
-                                return Err(Error::BadConfig);
-                            }
-                        };
-                    }
-
-                    Err(err) => {
-                        error!("tls_certificate is incorrectly configured: {:?}", err);
-                        return Err(Error::BadConfig);
-                    }
-                }
-            }
-            None => (),
-        };
-
-        for (_, pool) in &mut self.pools {
-            pool.validate()?;
-        }
-
-        Ok(())
+        info!("Sharding function: {}", self.query_router.sharding_function);
+        info!("Number of shards: {}", self.shards.len());
    }
 }

-/// Get a read-only instance of the configuration
-/// from anywhere in the app.
-/// ArcSwap makes this cheap and quick.
-pub fn get_config() -> Config {
-    (*(*CONFIG.load())).clone()
+pub fn get_config() -> Guard<Arc<Config>> {
+    CONFIG.load()
 }

-/// Parse the configuration file located at the path.
+/// Parse the config.
 pub async fn parse(path: &str) -> Result<(), Error> {
    let mut contents = String::new();
    let mut file = match File::open(path).await {
@@ -671,36 +266,93 @@ pub async fn parse(path: &str) -> Result<(), Error> {
        }
    };

-    config.validate()?;
-
-    config.path = path.to_string();
-
-    // Update the configuration globally.
-    CONFIG.store(Arc::new(config.clone()));
-
-    Ok(())
-}
-
-pub async fn reload_config(client_server_map: ClientServerMap) -> Result<bool, Error> {
-    let old_config = get_config();
-    match parse(&old_config.path).await {
-        Ok(()) => (),
-        Err(err) => {
-            error!("Config reload error: {:?}", err);
+    match config.query_router.sharding_function.as_ref() {
+        "pg_bigint_hash" => (),
+        "sha1" => (),
+        _ => {
+            error!(
+                "Supported sharding functions are: 'pg_bigint_hash', 'sha1', got: '{}'",
+                config.query_router.sharding_function
+            );
            return Err(Error::BadConfig);
        }
    };
-    let new_config = get_config();

-    if old_config.pools != new_config.pools {
-        info!("Pool configuration changed");
-        ConnectionPool::from_config(client_server_map).await?;
-        Ok(true)
-    } else if old_config != new_config {
-        Ok(true)
-    } else {
-        Ok(false)
+    // Quick config sanity check.
+    for shard in &config.shards {
+        // We use addresses as unique identifiers,
+        // let's make sure they are unique in the config as well.
+        let mut dup_check = HashSet::new();
+        let mut primary_count = 0;
+
+        match shard.0.parse::<usize>() {
+            Ok(_) => (),
+            Err(_) => {
+                error!(
+                    "Shard '{}' is not a valid number, shards must be numbered starting at 0",
+                    shard.0
+                );
+                return Err(Error::BadConfig);
+            }
+        };
+
+        if shard.1.servers.len() == 0 {
+            error!("Shard {} has no servers configured", shard.0);
+            return Err(Error::BadConfig);
+        }
+
+        for server in &shard.1.servers {
+            dup_check.insert(server);
+
+            // Check that we define only zero or one primary.
+            match server.2.as_ref() {
+                "primary" => primary_count += 1,
+                _ => (),
+            };
+
+            // Check role spelling.
+            match server.2.as_ref() {
+                "primary" => (),
+                "replica" => (),
+                _ => {
+                    error!(
+                        "Shard {} server role must be either 'primary' or 'replica', got: '{}'",
+                        shard.0, server.2
+                    );
+                    return Err(Error::BadConfig);
+                }
+            };
+        }
+
+        if primary_count > 1 {
+            error!("Shard {} has more than on primary configured", &shard.0);
+            return Err(Error::BadConfig);
+        }
+
+        if dup_check.len() != shard.1.servers.len() {
+            error!("Shard {} contains duplicate server configs", &shard.0);
+            return Err(Error::BadConfig);
+        }
    }
+
+    match config.query_router.default_role.as_ref() {
+        "any" => (),
+        "primary" => (),
+        "replica" => (),
+        other => {
+            error!(
+                "Query router default_role must be 'primary', 'replica', or 'any', got: '{}'",
+                other
+            );
+            return Err(Error::BadConfig);
+        }
+    };
+
+    config.path = Some(path.to_string());
+
+    CONFIG.store(Arc::new(config.clone()));
+
+    Ok(())
 }

 #[cfg(test)]
@@ -710,67 +362,11 @@ mod test {
    #[tokio::test]
    async fn test_config() {
        parse("pgcat.toml").await.unwrap();
-
-        assert_eq!(get_config().path, "pgcat.toml".to_string());
-
-        assert_eq!(get_config().general.ban_time, 60);
-        assert_eq!(get_config().pools.len(), 2);
-        assert_eq!(get_config().pools["sharded_db"].shards.len(), 3);
-        assert_eq!(get_config().pools["simple_db"].shards.len(), 1);
-        assert_eq!(get_config().pools["sharded_db"].users.len(), 2);
-        assert_eq!(get_config().pools["simple_db"].users.len(), 1);
-
-        assert_eq!(
-            get_config().pools["sharded_db"].shards["0"].servers[0].host,
-            "127.0.0.1"
-        );
-        assert_eq!(
-            get_config().pools["sharded_db"].shards["1"].servers[0].role,
-            Role::Primary
-        );
-        assert_eq!(
-            get_config().pools["sharded_db"].shards["1"].database,
-            "shard1"
-        );
-        assert_eq!(
-            get_config().pools["sharded_db"].users["0"].username,
-            "sharding_user"
-        );
-        assert_eq!(
-            get_config().pools["sharded_db"].users["1"].password,
-            "other_user"
-        );
-        assert_eq!(get_config().pools["sharded_db"].users["1"].pool_size, 21);
-        assert_eq!(get_config().pools["sharded_db"].default_role, "any");
-
-        assert_eq!(
-            get_config().pools["simple_db"].shards["0"].servers[0].host,
-            "127.0.0.1"
-        );
-        assert_eq!(
-            get_config().pools["simple_db"].shards["0"].servers[0].port,
-            5432
-        );
-        assert_eq!(
-            get_config().pools["simple_db"].shards["0"].database,
-            "some_db"
-        );
-        assert_eq!(get_config().pools["simple_db"].default_role, "primary");
-
-        assert_eq!(
-            get_config().pools["simple_db"].users["0"].username,
-            "simple_user"
-        );
-        assert_eq!(
-            get_config().pools["simple_db"].users["0"].password,
-            "simple_user"
-        );
-        assert_eq!(get_config().pools["simple_db"].users["0"].pool_size, 5);
-    }
-
-    #[tokio::test]
-    async fn test_serialize_configs() {
-        parse("pgcat.toml").await.unwrap();
-        print!("{}", toml::to_string(&get_config()).unwrap());
+        assert_eq!(get_config().general.pool_size, 15);
+        assert_eq!(get_config().shards.len(), 3);
+        assert_eq!(get_config().shards["1"].servers[0].0, "127.0.0.1");
+        assert_eq!(get_config().shards["0"].servers[0].2, "primary");
+        assert_eq!(get_config().query_router.default_role, "any");
+        assert_eq!(get_config().path, Some("pgcat.toml".to_string()));
    }
 }
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -1,6 +1,7 @@
 /// Various protocol constants, as defined in
-/// <https://www.postgresql.org/docs/12/protocol-message-formats.html>
+/// https://www.postgresql.org/docs/12/protocol-message-formats.html
 /// and elsewhere in the source code.
+/// Also other constants we use elsewhere.

 // Used in the StartupMessage to indicate regular handshake.
 pub const PROTOCOL_VERSION_NUMBER: i32 = 196608;
@@ -14,13 +15,6 @@ pub const CANCEL_REQUEST_CODE: i32 = 80877102;
 // AuthenticationMD5Password
 pub const MD5_ENCRYPTED_PASSWORD: i32 = 5;

-// SASL
-pub const SASL: i32 = 10;
-pub const SASL_CONTINUE: i32 = 11;
-pub const SASL_FINAL: i32 = 12;
-pub const SCRAM_SHA_256: &str = "SCRAM-SHA-256";
-pub const NONCE_LENGTH: usize = 24;
-
 // AuthenticationOk
 pub const AUTHENTICATION_SUCCESSFUL: i32 = 0;

--- a/src/errors.rs
+++ b/src/errors.rs
@@ -1,16 +1,14 @@
-/// Errors.
-
-/// Various errors.
 #[derive(Debug, PartialEq)]
 pub enum Error {
    SocketError,
+    // ClientDisconnected,
    ClientBadStartup,
    ProtocolSyncError,
    ServerError,
+    // ServerTimeout,
+    // DirtyServer,
    BadConfig,
+    BadUserList,
    AllServersDown,
-    ClientError,
-    TlsError,
-    StatementTimeout,
-    ShuttingDown,
+    AuthenticationError
 }
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,32 +0,0 @@
-pub mod config;
-pub mod constants;
-pub mod errors;
-pub mod messages;
-pub mod pool;
-pub mod scram;
-pub mod server;
-pub mod sharding;
-pub mod stats;
-pub mod tls;
-
-/// Format chrono::Duration to be more human-friendly.
-///
-/// # Arguments
-///
-/// * `duration` - A duration of time
-pub fn format_duration(duration: &chrono::Duration) -> String {
-    let milliseconds = format!("{:0>3}", duration.num_milliseconds() % 1000);
-
-    let seconds = format!("{:0>2}", duration.num_seconds() % 60);
-
-    let minutes = format!("{:0>2}", duration.num_minutes() % 60);
-
-    let hours = format!("{:0>2}", duration.num_hours() % 24);
-
-    let days = duration.num_days().to_string();
-
-    format!(
-        "{}d {}:{}:{}.{}",
-        days, hours, minutes, seconds, milliseconds
-    )
-}
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Lev Kokotov <hi@levthe.dev>
+// Copyright (c) 2022 Lev Kokotov <lev@levthe.dev>

 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
@@ -24,64 +24,58 @@ extern crate async_trait;
 extern crate bb8;
 extern crate bytes;
 extern crate env_logger;
-extern crate exitcode;
 extern crate log;
 extern crate md5;
 extern crate num_cpus;
 extern crate once_cell;
-extern crate rustls_pemfile;
 extern crate serde;
 extern crate serde_derive;
 extern crate sqlparser;
+extern crate statsd;
 extern crate tokio;
-extern crate tokio_rustls;
 extern crate toml;

-use log::{error, info, warn};
+use log::{error, info};
 use parking_lot::Mutex;
-use pgcat::format_duration;
 use tokio::net::TcpListener;
 use tokio::{
+    signal,
    signal::unix::{signal as unix_signal, SignalKind},
    sync::mpsc,
 };

 use std::collections::HashMap;
-use std::net::SocketAddr;
-use std::str::FromStr;
 use std::sync::Arc;
-use tokio::sync::broadcast;

 mod admin;
 mod client;
 mod config;
+mod userlist;
 mod constants;
 mod errors;
 mod messages;
 mod pool;
-mod prometheus;
 mod query_router;
-mod scram;
 mod server;
 mod sharding;
 mod stats;
-mod tls;

-use crate::config::{get_config, reload_config, VERSION};
-use crate::errors::Error;
-use crate::pool::{ClientServerMap, ConnectionPool};
-use crate::prometheus::start_metric_server;
-use crate::stats::{Collector, Reporter, REPORTER};
+// Support for query cancellation: this maps our process_ids and
+// secret keys to the backend's.
+use config::get_config;
+use pool::{ClientServerMap, ConnectionPool};
+use stats::{Collector, Reporter};

+/// Main!
 #[tokio::main(worker_threads = 4)]
 async fn main() {
-    env_logger::builder().format_timestamp_micros().init();
-
-    info!("Welcome to PgCat! Meow. (Version {})", VERSION);
+    env_logger::init();
+    info!("Welcome to PgCat! Meow.");

+    // Prepare regexes
    if !query_router::QueryRouter::setup() {
        error!("Could not setup query router");
-        std::process::exit(exitcode::CONFIG);
+        return;
    }

    let args = std::env::args().collect::<Vec<String>>();
@@ -92,213 +86,178 @@ async fn main() {
        String::from("pgcat.toml")
    };

+    // Prepare the config
    match config::parse(&config_file).await {
        Ok(_) => (),
        Err(err) => {
            error!("Config parse error: {:?}", err);
-            std::process::exit(exitcode::CONFIG);
+            return;
+        }
+    };
+
+    // Prepare user list
+    match userlist::parse("userlist.json").await {
+        Ok(_) => (),
+        Err(err) => {
+            error!("Userlist parse error: {:?}", err);
+            return;
        }
    };

    let config = get_config();

-    if let Some(true) = config.general.enable_prometheus_exporter {
-        let http_addr_str = format!(
-            "{}:{}",
-            config.general.host, config.general.prometheus_exporter_port
-        );
-        let http_addr = match SocketAddr::from_str(&http_addr_str) {
-            Ok(addr) => addr,
-            Err(err) => {
-                error!("Invalid http address: {}", err);
-                std::process::exit(exitcode::CONFIG);
-            }
-        };
-        tokio::task::spawn(async move {
-            start_metric_server(http_addr).await;
-        });
-    }
-
    let addr = format!("{}:{}", config.general.host, config.general.port);
-
    let listener = match TcpListener::bind(&addr).await {
        Ok(sock) => sock,
        Err(err) => {
            error!("Listener socket error: {:?}", err);
-            std::process::exit(exitcode::CONFIG);
+            return;
        }
    };

    info!("Running on {}", addr);
-
    config.show();

    // Tracks which client is connected to which server for query cancellation.
    let client_server_map: ClientServerMap = Arc::new(Mutex::new(HashMap::new()));

-    // Statistics reporting.
-    let (stats_tx, stats_rx) = mpsc::channel(100_000);
-    REPORTER.store(Arc::new(Reporter::new(stats_tx.clone())));
-
-    // Connection pool that allows to query all shards and replicas.
-    match ConnectionPool::from_config(client_server_map.clone()).await {
-        Ok(_) => (),
-        Err(err) => {
-            error!("Pool error: {:?}", err);
-            std::process::exit(exitcode::CONFIG);
-        }
-    };
-
+    // Collect statistics and send them to StatsD
+    let (tx, rx) = mpsc::channel(100);
+    let collector_tx = tx.clone();
    tokio::task::spawn(async move {
-        let mut stats_collector = Collector::new(stats_rx, stats_tx.clone());
+        let mut stats_collector = Collector::new(rx, collector_tx);
        stats_collector.collect().await;
    });

-    info!("Config autoreloader: {}", config.general.autoreload);
+    let mut pool =
+        ConnectionPool::from_config(client_server_map.clone(), Reporter::new(tx.clone())).await;

-    let mut autoreload_interval = tokio::time::interval(tokio::time::Duration::from_millis(15_000));
-    let autoreload_client_server_map = client_server_map.clone();
-    tokio::task::spawn(async move {
-        loop {
-            autoreload_interval.tick().await;
-            if config.general.autoreload {
-                info!("Automatically reloading config");
-
-                match reload_config(autoreload_client_server_map.clone()).await {
-                    Ok(changed) => {
-                        if changed {
-                            get_config().show()
-                        }
-                    }
-                    Err(_) => (),
-                };
-            }
+    let server_info = match pool.validate().await {
+        Ok(info) => info,
+        Err(err) => {
+            error!("Could not validate connection pool: {:?}", err);
+            return;
        }
-    });
-
-    let mut term_signal = unix_signal(SignalKind::terminate()).unwrap();
-    let mut interrupt_signal = unix_signal(SignalKind::interrupt()).unwrap();
-    let mut sighup_signal = unix_signal(SignalKind::hangup()).unwrap();
-    let (shutdown_tx, _) = broadcast::channel::<()>(1);
-    let (drain_tx, mut drain_rx) = mpsc::channel::<i32>(2048);
-    let (exit_tx, mut exit_rx) = mpsc::channel::<()>(1);
+    };

    info!("Waiting for clients");

-    let mut admin_only = false;
-    let mut total_clients = 0;
+    // Main app runs here.
+    tokio::task::spawn(async move {
+        loop {
+            let pool = pool.clone();
+            let client_server_map = client_server_map.clone();
+            let server_info = server_info.clone();
+            let reporter = Reporter::new(tx.clone());

-    loop {
-        tokio::select! {
-            // Reload config:
-            // kill -SIGHUP $(pgrep pgcat)
-            _ = sighup_signal.recv() => {
-                info!("Reloading config");
+            let (socket, addr) = match listener.accept().await {
+                Ok((socket, addr)) => (socket, addr),
+                Err(err) => {
+                    error!("{:?}", err);
+                    continue;
+                }
+            };

-                match reload_config(client_server_map.clone()).await {
-                    Ok(_) => (),
-                    Err(_) => (),
-                };
-
-                get_config().show();
-            },
-
-            // Initiate graceful shutdown sequence on sig int
-            _ = interrupt_signal.recv() => {
-                info!("Got SIGINT, waiting for client connection drain now");
-                admin_only = true;
-
-                // Broadcast that client tasks need to finish
-                let _ = shutdown_tx.send(());
-                let exit_tx = exit_tx.clone();
-                let _ = drain_tx.send(0).await;
-
-                tokio::task::spawn(async move {
-                    let mut interval = tokio::time::interval(tokio::time::Duration::from_millis(config.general.shutdown_timeout));
-
-                    // First tick fires immediately.
-                    interval.tick().await;
-
-                    // Second one in the interval time.
-                    interval.tick().await;
-
-                    // We're done waiting.
-                    error!("Graceful shutdown timed out. {} active clients being closed", total_clients);
-
-                    let _ = exit_tx.send(()).await;
-                });
-            },
-
-            _ = term_signal.recv() => {
-                info!("Got SIGTERM, closing with {} clients active", total_clients);
-                break;
-            },
-
-            new_client = listener.accept() => {
-                let (socket, addr) = match new_client {
-                    Ok((socket, addr)) => (socket, addr),
-                    Err(err) => {
-                        error!("{:?}", err);
-                        continue;
-                    }
-                };
-
-                let shutdown_rx = shutdown_tx.subscribe();
-                let drain_tx = drain_tx.clone();
-                let client_server_map = client_server_map.clone();
-
-                tokio::task::spawn(async move {
-                    let start = chrono::offset::Utc::now().naive_utc();
-
-                    match client::client_entrypoint(
-                        socket,
-                        client_server_map,
-                        shutdown_rx,
-                        drain_tx,
-                        admin_only,
-                    )
+            // Client goes to another thread, bye.
+            tokio::task::spawn(async move {
+                let start = chrono::offset::Utc::now().naive_utc();
+                match client::Client::startup(socket, client_server_map, server_info, reporter)
                    .await
-                    {
-                        Ok(()) => {
+                {
+                    Ok(mut client) => {
+                        info!("Client {:?} connected", addr);
+                        match client.handle(pool).await {
+                            Ok(()) => {
+                                let duration = chrono::offset::Utc::now().naive_utc() - start;

-                            let duration = chrono::offset::Utc::now().naive_utc() - start;
-
-                            info!(
-                                "Client {:?} disconnected, session duration: {}",
-                                addr,
-                                format_duration(&duration)
-                            );
-                        }
-
-                        Err(err) => {
-                            match err {
-                                // Don't count the clients we rejected.
-                                Error::ShuttingDown => (),
-                                _ => {
-                                    // drain_tx.send(-1).await.unwrap();
-                                }
+                                info!(
+                                    "Client {:?} disconnected, session duration: {}",
+                                    addr,
+                                    format_duration(&duration)
+                                );
                            }

-                            warn!("Client disconnected with error {:?}", err);
+                            Err(err) => {
+                                error!("Client disconnected with error: {:?}", err);
+                                client.release();
+                            }
                        }
-                    };
-                });
-            }
+                    }

-            _ = exit_rx.recv() => {
-                break;
-            }
-
-            client_ping = drain_rx.recv() => {
-                let client_ping = client_ping.unwrap();
-                total_clients += client_ping;
-
-                if total_clients == 0 && admin_only {
-                    let _ = exit_tx.send(()).await;
-                }
-            }
+                    Err(err) => {
+                        error!("Client failed to login: {:?}", err);
+                    }
+                };
+            });
        }
-    }
+    });

-    info!("Shutting down...");
+    // Reload config
+    // kill -SIGHUP $(pgrep pgcat)
+    tokio::task::spawn(async move {
+        let mut stream = unix_signal(SignalKind::hangup()).unwrap();
+
+        loop {
+            stream.recv().await;
+            info!("Reloading config");
+            match config::parse("pgcat.toml").await {
+                Ok(_) => {
+                    get_config().show();
+                }
+                Err(err) => {
+                    error!("{:?}", err);
+                    return;
+                }
+            };
+        }
+    });
+
+    // Setup shut down sequence
+    match signal::ctrl_c().await {
+        Ok(()) => {
+            info!("Shutting down...");
+        }
+
+        Err(err) => {
+            error!("Unable to listen for shutdown signal: {}", err);
+        }
+    };
+}
+
+/// Format chrono::Duration to be more human-friendly.
+///
+/// # Arguments
+///
+/// * `duration` - A duration of time
+fn format_duration(duration: &chrono::Duration) -> String {
+    let seconds = {
+        let seconds = duration.num_seconds() % 60;
+        if seconds < 10 {
+            format!("0{}", seconds)
+        } else {
+            format!("{}", seconds)
+        }
+    };
+
+    let minutes = {
+        let minutes = duration.num_minutes() % 60;
+        if minutes < 10 {
+            format!("0{}", minutes)
+        } else {
+            format!("{}", minutes)
+        }
+    };
+
+    let hours = {
+        let hours = duration.num_hours() % 24;
+        if hours < 10 {
+            format!("0{}", hours)
+        } else {
+            format!("{}", hours)
+        }
+    };
+
+    let days = duration.num_days().to_string();
+
+    format!("{}d {}:{}:{}", days, hours, minutes, seconds)
 }
--- a/src/messages.rs
+++ b/src/messages.rs
@@ -1,13 +1,23 @@
 /// Helper functions to send one-off protocol messages
 /// and handle TcpStream (TCP socket).
+
+
 use bytes::{Buf, BufMut, BytesMut};
 use md5::{Digest, Md5};
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::TcpStream;
+use tokio::io::{AsyncReadExt, AsyncWriteExt, BufReader};
+use tokio::net::{
+    tcp::{OwnedReadHalf, OwnedWriteHalf},
+    TcpStream,
+};
+use log::{error};

 use crate::errors::Error;
 use std::collections::HashMap;
-use std::mem;
+
+use rand::Rng;
+
+use crate::userlist::get_user_list;
+

 /// Postgres data type mappings
 /// used in RowDescription ('T') message.
@@ -27,11 +37,97 @@ impl From<&DataType> for i32 {
    }
 }

+/**
+1. Generate salt (4 bytes of random data)
+md5(concat(md5(concat(password, username)), random-salt)))
+2. Send md5 auth request
+3. recieve PasswordMessage with salt.
+4. refactor md5_password function to be reusable
+5. check username hash combo against file
+6. AuthenticationOk or ErrorResponse
+ **/
+pub async fn start_auth(stream: &mut TcpStream, user: &str) -> Result<(), Error> {
+    //Generate random 4 byte salt
+    let salt = rand::random::<u32>();
+
+    // Send AuthenticationMD5Password request
+    send_md5_request(stream, salt).await?;
+
+    let code = match stream.read_u8().await {
+        Ok(code) => code as char,
+        Err(_) => return Err(Error::AuthenticationError),
+    };
+
+    match code {
+        // Password response
+        'p' => {
+            fetch_password_and_authenticate(stream, user, &salt).await?;
+            Ok(auth_ok(stream).await?)
+        }
+        _ => {
+            error!("Unknown code: {}", code);
+            return Err(Error::AuthenticationError);
+        }
+    }
+}
+
+pub async fn send_md5_request(stream: &mut TcpStream, salt: u32) -> Result<(), Error> {
+    let mut authentication_md5password = BytesMut::with_capacity(12);
+    authentication_md5password.put_u8(b'R');
+    authentication_md5password.put_i32(12);
+    authentication_md5password.put_i32(5);
+    authentication_md5password.put_u32(salt);
+
+    // Send AuthenticationMD5Password request
+    Ok(write_all(stream, authentication_md5password).await?)
+}
+
+pub async fn fetch_password_and_authenticate(stream: &mut TcpStream, user: &str, salt: &u32) -> Result<(), Error> {
+    /**
+    1. How do I store the lists of users and paswords? clear text or hash?? wtf
+    2. Add auth to tests
+    **/
+
+    let len = match stream.read_i32().await {
+        Ok(len) => len,
+        Err(_) => return Err(Error::AuthenticationError),
+    };
+
+    // Read whatever is left.
+    let mut password_hash = vec![0u8; len as usize - 4];
+
+    match stream.read_exact(&mut password_hash).await {
+        Ok(_) => (),
+        Err(_) => return Err(Error::AuthenticationError),
+    };
+
+    let user_list = get_user_list();
+    let mut password = match user_list.get(user) {
+        Some(p) => p,
+        None => return Err(Error::AuthenticationError),
+    };
+
+    let mut md5 = Md5::new();
+
+    //    concat('md5', md5(concat(md5(concat(password, username)), random-salt)))
+    // First pass
+    md5.update(&password.as_bytes());
+    md5.update(&user.as_bytes());
+    let output = md5.finalize_reset();
+    // Second pass
+    md5.update(format!("{:x}", output));
+    md5.update(salt.to_be_bytes().to_vec());
+
+
+    let password_string: String = String::from_utf8(password_hash).expect("Could not get password hash");
+    match format!("md5{:x}", md5.finalize()) == password_string {
+        true => Ok(()),
+        _ => Err(Error::AuthenticationError)
+    }
+}
+
 /// Tell the client that authentication handshake completed successfully.
-pub async fn auth_ok<S>(stream: &mut S) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+pub async fn auth_ok(stream: &mut TcpStream) -> Result<(), Error> {
    let mut auth_ok = BytesMut::with_capacity(9);

    auth_ok.put_u8(b'R');
@@ -41,39 +137,13 @@ where
    Ok(write_all(stream, auth_ok).await?)
 }

-/// Generate md5 password challenge.
-pub async fn md5_challenge<S>(stream: &mut S) -> Result<[u8; 4], Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    // let mut rng = rand::thread_rng();
-    let salt: [u8; 4] = [
-        rand::random(),
-        rand::random(),
-        rand::random(),
-        rand::random(),
-    ];
-
-    let mut res = BytesMut::new();
-    res.put_u8(b'R');
-    res.put_i32(12);
-    res.put_i32(5); // MD5
-    res.put_slice(&salt[..]);
-
-    write_all(stream, res).await?;
-    Ok(salt)
-}
-
 /// Give the client the process_id and secret we generated
 /// used in query cancellation.
-pub async fn backend_key_data<S>(
-    stream: &mut S,
+pub async fn backend_key_data(
+    stream: &mut TcpStream,
    backend_id: i32,
    secret_key: i32,
-) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+) -> Result<(), Error> {
    let mut key_data = BytesMut::from(&b"K"[..]);
    key_data.put_i32(12);
    key_data.put_i32(backend_id);
@@ -94,13 +164,8 @@ pub fn simple_query(query: &str) -> BytesMut {
 }

 /// Tell the client we're ready for another query.
-pub async fn ready_for_query<S>(stream: &mut S) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    let mut bytes = BytesMut::with_capacity(
-        mem::size_of::<u8>() + mem::size_of::<i32>() + mem::size_of::<u8>(),
-    );
+pub async fn ready_for_query(stream: &mut TcpStream) -> Result<(), Error> {
+    let mut bytes = BytesMut::with_capacity(5);

    bytes.put_u8(b'Z');
    bytes.put_i32(5);
@@ -192,8 +257,14 @@ pub fn parse_startup(bytes: BytesMut) -> Result<HashMap<String, String>, Error>
    Ok(result)
 }

-/// Create md5 password hash given a salt.
-pub fn md5_hash_password(user: &str, password: &str, salt: &[u8]) -> Vec<u8> {
+/// Send password challenge response to the server.
+/// This is the MD5 challenge.
+pub async fn md5_password(
+    stream: &mut TcpStream,
+    user: &str,
+    password: &str,
+    salt: &[u8],
+) -> Result<(), Error> {
    let mut md5 = Md5::new();

    // First pass
@@ -212,22 +283,6 @@ pub fn md5_hash_password(user: &str, password: &str, salt: &[u8]) -> Vec<u8> {
        .collect::<Vec<u8>>();
    password.push(0);

-    password
-}
-
-/// Send password challenge response to the server.
-/// This is the MD5 challenge.
-pub async fn md5_password<S>(
-    stream: &mut S,
-    user: &str,
-    password: &str,
-    salt: &[u8],
-) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    let password = md5_hash_password(user, password, salt);
-
    let mut message = BytesMut::with_capacity(password.len() as usize + 5);

    message.put_u8(b'p');
@@ -240,10 +295,10 @@ where
 /// Implements a response to our custom `SET SHARDING KEY`
 /// and `SET SERVER ROLE` commands.
 /// This tells the client we're ready for the next query.
-pub async fn custom_protocol_response_ok<S>(stream: &mut S, message: &str) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+pub async fn custom_protocol_response_ok(
+    stream: &mut OwnedWriteHalf,
+    message: &str,
+) -> Result<(), Error> {
    let mut res = BytesMut::with_capacity(25);

    let set_complete = BytesMut::from(&format!("{}\0", message)[..]);
@@ -254,28 +309,18 @@ where
    res.put_i32(len);
    res.put_slice(&set_complete[..]);

-    write_all_half(stream, res).await?;
-    ready_for_query(stream).await
+    // ReadyForQuery (idle)
+    res.put_u8(b'Z');
+    res.put_i32(5);
+    res.put_u8(b'I');
+
+    write_all_half(stream, res).await
 }

 /// Send a custom error message to the client.
 /// Tell the client we are ready for the next query and no rollback is necessary.
-/// Docs on error codes: <https://www.postgresql.org/docs/12/errcodes-appendix.html>.
-pub async fn error_response<S>(stream: &mut S, message: &str) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    error_response_terminal(stream, message).await?;
-    ready_for_query(stream).await
-}
-
-/// Send a custom error message to the client.
-/// Tell the client we are ready for the next query and no rollback is necessary.
-/// Docs on error codes: <https://www.postgresql.org/docs/12/errcodes-appendix.html>.
-pub async fn error_response_terminal<S>(stream: &mut S, message: &str) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+/// Docs on error codes: https://www.postgresql.org/docs/12/errcodes-appendix.html
+pub async fn error_response(stream: &mut OwnedWriteHalf, message: &str) -> Result<(), Error> {
    let mut error = BytesMut::new();

    // Error level
@@ -297,57 +342,31 @@ where
    // No more fields follow.
    error.put_u8(0);

+    // Ready for query, no rollback needed (I = idle).
+    let mut ready_for_query = BytesMut::new();
+
+    ready_for_query.put_u8(b'Z');
+    ready_for_query.put_i32(5);
+    ready_for_query.put_u8(b'I');
+
    // Compose the two message reply.
-    let mut res = BytesMut::with_capacity(error.len() + 5);
+    let mut res = BytesMut::with_capacity(error.len() + ready_for_query.len() + 5);

    res.put_u8(b'E');
    res.put_i32(error.len() as i32 + 4);
+
    res.put(error);
+    res.put(ready_for_query);

    Ok(write_all_half(stream, res).await?)
 }

-pub async fn wrong_password<S>(stream: &mut S, user: &str) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
-    let mut error = BytesMut::new();
-
-    // Error level
-    error.put_u8(b'S');
-    error.put_slice(&b"FATAL\0"[..]);
-
-    // Error level (non-translatable)
-    error.put_u8(b'V');
-    error.put_slice(&b"FATAL\0"[..]);
-
-    // Error code: not sure how much this matters.
-    error.put_u8(b'C');
-    error.put_slice(&b"28P01\0"[..]); // system_error, see Appendix A.
-
-    // The short error message.
-    error.put_u8(b'M');
-    error.put_slice(&format!("password authentication failed for user \"{}\"\0", user).as_bytes());
-
-    // No more fields follow.
-    error.put_u8(0);
-
-    // Compose the two message reply.
-    let mut res = BytesMut::new();
-
-    res.put_u8(b'E');
-    res.put_i32(error.len() as i32 + 4);
-
-    res.put(error);
-
-    write_all(stream, res).await
-}
-
 /// Respond to a SHOW SHARD command.
-pub async fn show_response<S>(stream: &mut S, name: &str, value: &str) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+pub async fn show_response(
+    stream: &mut OwnedWriteHalf,
+    name: &str,
+    value: &str,
+) -> Result<(), Error> {
    // A SELECT response consists of:
    // 1. RowDescription
    // 2. One or more DataRow
@@ -366,8 +385,12 @@ where
    // CommandComplete
    res.put(command_complete("SELECT 1"));

-    write_all_half(stream, res).await?;
-    ready_for_query(stream).await
+    // ReadyForQuery
+    res.put_u8(b'Z');
+    res.put_i32(5);
+    res.put_u8(b'I');
+
+    write_all_half(stream, res).await
 }

 pub fn row_description(columns: &Vec<(&str, DataType)>) -> BytesMut {
@@ -413,7 +436,6 @@ pub fn row_description(columns: &Vec<(&str, DataType)>) -> BytesMut {
    res
 }

-/// Create a DataRow message.
 pub fn data_row(row: &Vec<String>) -> BytesMut {
    let mut res = BytesMut::new();
    let mut data_row = BytesMut::new();
@@ -433,7 +455,6 @@ pub fn data_row(row: &Vec<String>) -> BytesMut {
    res
 }

-/// Create a CommandComplete message.
 pub fn command_complete(command: &str) -> BytesMut {
    let cmd = BytesMut::from(format!("{}\0", command).as_bytes());
    let mut res = BytesMut::new();
@@ -444,10 +465,7 @@ pub fn command_complete(command: &str) -> BytesMut {
 }

 /// Write all data in the buffer to the TcpStream.
-pub async fn write_all<S>(stream: &mut S, buf: BytesMut) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+pub async fn write_all(stream: &mut TcpStream, buf: BytesMut) -> Result<(), Error> {
    match stream.write_all(&buf).await {
        Ok(_) => Ok(()),
        Err(_) => return Err(Error::SocketError),
@@ -455,10 +473,7 @@ where
 }

 /// Write all the data in the buffer to the TcpStream, write owned half (see mpsc).
-pub async fn write_all_half<S>(stream: &mut S, buf: BytesMut) -> Result<(), Error>
-where
-    S: tokio::io::AsyncWrite + std::marker::Unpin,
-{
+pub async fn write_all_half(stream: &mut OwnedWriteHalf, buf: BytesMut) -> Result<(), Error> {
    match stream.write_all(&buf).await {
        Ok(_) => Ok(()),
        Err(_) => return Err(Error::SocketError),
@@ -466,10 +481,7 @@ where
 }

 /// Read a complete message from the socket.
-pub async fn read_message<S>(stream: &mut S) -> Result<BytesMut, Error>
-where
-    S: tokio::io::AsyncRead + std::marker::Unpin,
-{
+pub async fn read_message(stream: &mut BufReader<OwnedReadHalf>) -> Result<BytesMut, Error> {
    let code = match stream.read_u8().await {
        Ok(code) => code,
        Err(_) => return Err(Error::SocketError),
@@ -495,20 +507,3 @@ where

    Ok(bytes)
 }
-
-pub fn server_parameter_message(key: &str, value: &str) -> BytesMut {
-    let mut server_info = BytesMut::new();
-
-    let null_byte_size = 1;
-    let len: usize =
-        mem::size_of::<i32>() + key.len() + null_byte_size + value.len() + null_byte_size;
-
-    server_info.put_slice("S".as_bytes());
-    server_info.put_i32(len.try_into().unwrap());
-    server_info.put_slice(key.as_bytes());
-    server_info.put_bytes(0, 1);
-    server_info.put_slice(value.as_bytes());
-    server_info.put_bytes(0, 1);
-
-    return server_info;
-}
--- a/src/pool.rs
+++ b/src/pool.rs
@@ -1,281 +1,116 @@
-use arc_swap::ArcSwap;
+/// Pooling and failover and banlist.
 use async_trait::async_trait;
 use bb8::{ManageConnection, Pool, PooledConnection};
 use bytes::BytesMut;
 use chrono::naive::NaiveDateTime;
 use log::{debug, error, info, warn};
-use once_cell::sync::Lazy;
 use parking_lot::{Mutex, RwLock};
-use rand::seq::SliceRandom;
-use rand::thread_rng;
-use std::collections::{HashMap, HashSet};
+
+use crate::config::{get_config, Address, Role, User};
+use crate::errors::Error;
+use crate::server::Server;
+use crate::stats::Reporter;
+
+use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Instant;

-use crate::config::{get_config, Address, PoolMode, Role, User};
-use crate::errors::Error;
-
-use crate::server::Server;
-use crate::sharding::ShardingFunction;
-use crate::stats::{get_reporter, Reporter};
-
-pub type ProcessId = i32;
-pub type SecretKey = i32;
-pub type ServerHost = String;
-pub type ServerPort = u16;
-
+// Banlist: bad servers go in here.
 pub type BanList = Arc<RwLock<Vec<HashMap<Address, NaiveDateTime>>>>;
-pub type ClientServerMap =
-    Arc<Mutex<HashMap<(ProcessId, SecretKey), (ProcessId, SecretKey, ServerHost, ServerPort)>>>;
-pub type PoolMap = HashMap<PoolIdentifier, ConnectionPool>;
-/// The connection pool, globally available.
-/// This is atomic and safe and read-optimized.
-/// The pool is recreated dynamically when the config is reloaded.
-pub static POOLS: Lazy<ArcSwap<PoolMap>> = Lazy::new(|| ArcSwap::from_pointee(HashMap::default()));
-static POOLS_HASH: Lazy<ArcSwap<HashSet<crate::config::Pool>>> =
-    Lazy::new(|| ArcSwap::from_pointee(HashSet::default()));
+pub type ClientServerMap = Arc<Mutex<HashMap<(i32, i32), (i32, i32, String, String)>>>;

-/// An identifier for a PgCat pool,
-/// a database visible to clients.
-#[derive(Hash, Debug, Clone, PartialEq, Eq)]
-pub struct PoolIdentifier {
-    // The name of the database clients want to connect to.
-    pub db: String,
-
-    /// The username the client connects with. Each user gets its own pool.
-    pub user: String,
-}
-
-impl PoolIdentifier {
-    /// Create a new user/pool identifier.
-    pub fn new(db: &str, user: &str) -> PoolIdentifier {
-        PoolIdentifier {
-            db: db.to_string(),
-            user: user.to_string(),
-        }
-    }
-}
-
-/// Pool settings.
 #[derive(Clone, Debug)]
-pub struct PoolSettings {
-    /// Transaction or Session.
-    pub pool_mode: PoolMode,
-
-    // Number of shards.
-    pub shards: usize,
-
-    // Connecting user.
-    pub user: User,
-
-    // Default server role to connect to.
-    pub default_role: Option<Role>,
-
-    // Enable/disable query parser.
-    pub query_parser_enabled: bool,
-
-    // Read from the primary as well or not.
-    pub primary_reads_enabled: bool,
-
-    // Sharding function.
-    pub sharding_function: ShardingFunction,
-}
-
-impl Default for PoolSettings {
-    fn default() -> PoolSettings {
-        PoolSettings {
-            pool_mode: PoolMode::Transaction,
-            shards: 1,
-            user: User::default(),
-            default_role: None,
-            query_parser_enabled: false,
-            primary_reads_enabled: true,
-            sharding_function: ShardingFunction::PgBigintHash,
-        }
-    }
-}
-
-/// The globally accessible connection pool.
-#[derive(Clone, Debug, Default)]
 pub struct ConnectionPool {
-    /// The pools handled internally by bb8.
    databases: Vec<Vec<Pool<ServerPool>>>,
-
-    /// The addresses (host, port, role) to handle
-    /// failover and load balancing deterministically.
    addresses: Vec<Vec<Address>>,
-
-    /// List of banned addresses (see above)
-    /// that should not be queried.
+    round_robin: usize,
    banlist: BanList,
-
-    /// The statistics aggregator runs in a separate task
-    /// and receives stats from clients, servers, and the pool.
    stats: Reporter,
-
-    /// The server information (K messages) have to be passed to the
-    /// clients on startup. We pre-connect to all shards and replicas
-    /// on pool creation and save the K messages here.
-    server_info: BytesMut,
-
-    /// Pool configuration.
-    pub settings: PoolSettings,
 }

 impl ConnectionPool {
-    /// Construct the connection pool from the configuration.
-    pub async fn from_config(client_server_map: ClientServerMap) -> Result<(), Error> {
+    /// Construct the connection pool from a config file.
+    pub async fn from_config(
+        client_server_map: ClientServerMap,
+        stats: Reporter,
+    ) -> ConnectionPool {
        let config = get_config();
+        let mut shards = Vec::new();
+        let mut addresses = Vec::new();
+        let mut banlist = Vec::new();
+        let mut shard_ids = config
+            .shards
+            .clone()
+            .into_keys()
+            .map(|x| x.to_string())
+            .collect::<Vec<String>>();
+        shard_ids.sort_by_key(|k| k.parse::<i64>().unwrap());

-        let mut new_pools = HashMap::new();
-        let mut address_id = 0;
+        for shard_idx in shard_ids {
+            let shard = &config.shards[&shard_idx];
+            let mut pools = Vec::new();
+            let mut servers = Vec::new();
+            let mut replica_number = 0;

-        let mut pools_hash = (*(*POOLS_HASH.load())).clone();
-
-        for (pool_name, pool_config) in &config.pools {
-            let changed = pools_hash.insert(pool_config.clone());
-
-            // There is one pool per database/user pair.
-            for (_, user) in &pool_config.users {
-                // If the pool hasn't changed, get existing reference and insert it into the new_pools.
-                // We replace all pools at the end, but if the reference is kept, the pool won't get re-created (bb8).
-                if !changed {
-                    match get_pool(&pool_name, &user.username) {
-                        Some(pool) => {
-                            info!(
-                                "[pool: {}][user: {}] has not changed",
-                                pool_name, user.username
-                            );
-                            new_pools.insert(
-                                PoolIdentifier::new(&pool_name, &user.username),
-                                pool.clone(),
-                            );
-                            continue;
-                        }
-                        None => (),
+            for server in shard.servers.iter() {
+                let role = match server.2.as_ref() {
+                    "primary" => Role::Primary,
+                    "replica" => Role::Replica,
+                    _ => {
+                        error!("Config error: server role can be 'primary' or 'replica', have: '{}'. Defaulting to 'replica'.", server.2);
+                        Role::Replica
                    }
+                };
+
+                let address = Address {
+                    host: server.0.clone(),
+                    port: server.1.to_string(),
+                    role: role,
+                    replica_number,
+                    shard: shard_idx.parse::<usize>().unwrap(),
+                };
+
+                if role == Role::Replica {
+                    replica_number += 1;
                }

-                info!(
-                    "[pool: {}][user: {}] creating new pool",
-                    pool_name, user.username
+                let manager = ServerPool::new(
+                    address.clone(),
+                    config.user.clone(),
+                    &shard.database,
+                    client_server_map.clone(),
+                    stats.clone(),
                );

-                let mut shards = Vec::new();
-                let mut addresses = Vec::new();
-                let mut banlist = Vec::new();
-                let mut shard_ids = pool_config
-                    .shards
-                    .clone()
-                    .into_keys()
-                    .map(|x| x.to_string())
-                    .collect::<Vec<String>>();
+                let pool = Pool::builder()
+                    .max_size(config.general.pool_size)
+                    .connection_timeout(std::time::Duration::from_millis(
+                        config.general.connect_timeout,
+                    ))
+                    .test_on_check_out(false)
+                    .build(manager)
+                    .await
+                    .unwrap();

-                // Sort by shard number to ensure consistency.
-                shard_ids.sort_by_key(|k| k.parse::<i64>().unwrap());
-
-                for shard_idx in &shard_ids {
-                    let shard = &pool_config.shards[shard_idx];
-                    let mut pools = Vec::new();
-                    let mut servers = Vec::new();
-                    let mut address_index = 0;
-                    let mut replica_number = 0;
-
-                    for server in shard.servers.iter() {
-                        let address = Address {
-                            id: address_id,
-                            database: shard.database.clone(),
-                            host: server.host.clone(),
-                            port: server.port,
-                            role: server.role,
-                            address_index,
-                            replica_number,
-                            shard: shard_idx.parse::<usize>().unwrap(),
-                            username: user.username.clone(),
-                            pool_name: pool_name.clone(),
-                        };
-
-                        address_id += 1;
-                        address_index += 1;
-
-                        if server.role == Role::Replica {
-                            replica_number += 1;
-                        }
-
-                        let manager = ServerPool::new(
-                            address.clone(),
-                            user.clone(),
-                            &shard.database,
-                            client_server_map.clone(),
-                            get_reporter(),
-                        );
-
-                        let connect_timeout = match pool_config.connect_timeout {
-                            Some(connect_timeout) => connect_timeout,
-                            None => config.general.connect_timeout,
-                        };
-
-                        let pool = Pool::builder()
-                            .max_size(user.pool_size)
-                            .connection_timeout(std::time::Duration::from_millis(connect_timeout))
-                            .test_on_check_out(false)
-                            .build(manager)
-                            .await
-                            .unwrap();
-
-                        pools.push(pool);
-                        servers.push(address);
-                    }
-
-                    shards.push(pools);
-                    addresses.push(servers);
-                    banlist.push(HashMap::new());
-                }
-
-                assert_eq!(shards.len(), addresses.len());
-
-                let mut pool = ConnectionPool {
-                    databases: shards,
-                    addresses: addresses,
-                    banlist: Arc::new(RwLock::new(banlist)),
-                    stats: get_reporter(),
-                    server_info: BytesMut::new(),
-                    settings: PoolSettings {
-                        pool_mode: pool_config.pool_mode,
-                        // shards: pool_config.shards.clone(),
-                        shards: shard_ids.len(),
-                        user: user.clone(),
-                        default_role: match pool_config.default_role.as_str() {
-                            "any" => None,
-                            "replica" => Some(Role::Replica),
-                            "primary" => Some(Role::Primary),
-                            _ => unreachable!(),
-                        },
-                        query_parser_enabled: pool_config.query_parser_enabled.clone(),
-                        primary_reads_enabled: pool_config.primary_reads_enabled,
-                        sharding_function: pool_config.sharding_function,
-                    },
-                };
-
-                // Connect to the servers to make sure pool configuration is valid
-                // before setting it globally.
-                match pool.validate().await {
-                    Ok(_) => (),
-                    Err(err) => {
-                        error!("Could not validate connection pool: {:?}", err);
-                        return Err(err);
-                    }
-                };
-
-                // There is one pool per database/user pair.
-                new_pools.insert(PoolIdentifier::new(&pool_name, &user.username), pool);
+                pools.push(pool);
+                servers.push(address);
            }
+
+            shards.push(pools);
+            addresses.push(servers);
+            banlist.push(HashMap::new());
        }

-        POOLS.store(Arc::new(new_pools.clone()));
-        POOLS_HASH.store(Arc::new(pools_hash.clone()));
+        assert_eq!(shards.len(), addresses.len());
+        let address_len = addresses.len();

-        Ok(())
+        ConnectionPool {
+            databases: shards,
+            addresses: addresses,
+            round_robin: rand::random::<usize>() % address_len, // Start at a random replica
+            banlist: Arc::new(RwLock::new(banlist)),
+            stats: stats,
+        }
    }

    /// Connect to all shards and grab server information.
@@ -283,11 +118,12 @@ impl ConnectionPool {
    /// when they connect.
    /// This also warms up the pool for clients that connect when
    /// the pooler starts up.
-    async fn validate(&mut self) -> Result<(), Error> {
+    pub async fn validate(&mut self) -> Result<BytesMut, Error> {
        let mut server_infos = Vec::new();
+
        for shard in 0..self.shards() {
-            for server in 0..self.servers(shard) {
-                let connection = match self.databases[shard][server].get().await {
+            for _ in 0..self.servers(shard) {
+                let connection = match self.get(shard, None).await {
                    Ok(conn) => conn,
                    Err(err) => {
                        error!("Shard {} down or misconfigured: {:?}", shard, err);
@@ -295,8 +131,10 @@ impl ConnectionPool {
                    }
                };

-                let proxy = connection;
-                let server = &*proxy;
+                let mut proxy = connection.0;
+                let address = connection.1;
+                let server = &mut *proxy;
+
                let server_info = server.server_info();

                if server_infos.len() > 0 {
@@ -304,7 +142,7 @@ impl ConnectionPool {
                    if server_info != server_infos[server_infos.len() - 1] {
                        warn!(
                            "{:?} has different server configuration than the last server",
-                            proxy.address()
+                            address
                        );
                    }
                }
@@ -319,161 +157,141 @@ impl ConnectionPool {
            return Err(Error::AllServersDown);
        }

-        // We're assuming all servers are identical.
-        // TODO: not true.
-        self.server_info = server_infos[0].clone();
-
-        Ok(())
+        Ok(server_infos[0].clone())
    }

    /// Get a connection from the pool.
    pub async fn get(
-        &self,
-        shard: usize,       // shard number
-        role: Option<Role>, // primary or replica
-        process_id: i32,    // client id
+        &mut self,
+        shard: usize,
+        role: Option<Role>,
    ) -> Result<(PooledConnection<'_, ServerPool>, Address), Error> {
-        let mut candidates: Vec<&Address> = self.addresses[shard]
-            .iter()
-            .filter(|address| address.role == role)
-            .collect();
+        let now = Instant::now();
+        let addresses = &self.addresses[shard];

-        // Random load balancing
-        candidates.shuffle(&mut thread_rng());
+        let mut allowed_attempts = match role {
+            // Primary-specific queries get one attempt, if the primary is down,
+            // nothing we should do about it I think. It's dangerous to retry
+            // write queries.
+            Some(Role::Primary) => 1,

-        let healthcheck_timeout = get_config().general.healthcheck_timeout;
-        let healthcheck_delay = get_config().general.healthcheck_delay as u128;
+            // Replicas get to try as many times as there are replicas
+            // and connections in the pool.
+            _ => addresses.len(),
+        };

-        while !candidates.is_empty() {
-            // Get the next candidate
-            let address = match candidates.pop() {
-                Some(address) => address,
-                None => break,
-            };
+        debug!("Allowed attempts for {:?}: {}", role, allowed_attempts);

-            if self.is_banned(&address, role) {
-                debug!("Address {:?} is banned", address);
+        let exists = match role {
+            Some(role) => addresses.iter().filter(|addr| addr.role == role).count() > 0,
+            None => true,
+        };
+
+        if !exists {
+            error!("Requested role {:?}, but none are configured", role);
+            return Err(Error::BadConfig);
+        }
+
+        while allowed_attempts > 0 {
+            // Round-robin each client's queries.
+            // If a client only sends one query and then disconnects, it doesn't matter
+            // which replica it'll go to.
+            self.round_robin += 1;
+            let index = self.round_robin % addresses.len();
+            let address = &addresses[index];
+
+            // Make sure you're getting a primary or a replica
+            // as per request. If no specific role is requested, the first
+            // available will be chosen.
+            if address.role != role {
                continue;
            }

-            // Indicate we're waiting on a server connection from a pool.
-            let now = Instant::now();
-            self.stats.client_waiting(process_id);
+            allowed_attempts -= 1;
+
+            if self.is_banned(address, shard, role) {
+                continue;
+            }

            // Check if we can connect
-            let mut conn = match self.databases[address.shard][address.address_index]
-                .get()
-                .await
-            {
+            let mut conn = match self.databases[shard][index].get().await {
                Ok(conn) => conn,
                Err(err) => {
-                    error!("Banning instance {:?}, error: {:?}", address, err);
-                    self.ban(&address, process_id);
-                    self.stats.client_checkout_error(process_id, address.id);
+                    error!("Banning replica {}, error: {:?}", index, err);
+                    self.ban(address, shard);
                    continue;
                }
            };

-            // // Check if this server is alive with a health check.
+            // // Check if this server is alive with a health check
            let server = &mut *conn;
+            let healthcheck_timeout = get_config().general.healthcheck_timeout;

-            // Will return error if timestamp is greater than current system time, which it should never be set to
-            let require_healthcheck =
-                server.last_activity().elapsed().unwrap().as_millis() > healthcheck_delay;
-
-            // Do not issue a health check unless it's been a little while
-            // since we last checked the server is ok.
-            // Health checks are pretty expensive.
-            if !require_healthcheck {
-                self.stats
-                    .checkout_time(now.elapsed().as_micros(), process_id, server.server_id());
-                self.stats.server_active(process_id, server.server_id());
-                return Ok((conn, address.clone()));
-            }
-
-            debug!("Running health check on server {:?}", address);
-
-            self.stats.server_tested(server.server_id());
+            self.stats.server_tested(server.process_id());

            match tokio::time::timeout(
                tokio::time::Duration::from_millis(healthcheck_timeout),
-                server.query(";"), // Cheap query as it skips the query planner
+                server.query("SELECT 1"),
            )
            .await
            {
-                // Check if health check succeeded.
+                // Check if health check succeeded
                Ok(res) => match res {
                    Ok(_) => {
-                        self.stats.checkout_time(
-                            now.elapsed().as_micros(),
-                            process_id,
-                            conn.server_id(),
-                        );
-                        self.stats.server_active(process_id, conn.server_id());
+                        self.stats.checkout_time(now.elapsed().as_micros());
+                        self.stats.server_idle(conn.process_id());
                        return Ok((conn, address.clone()));
                    }
-
-                    // Health check failed.
-                    Err(err) => {
-                        error!(
-                            "Banning instance {:?} because of failed health check, {:?}",
-                            address, err
-                        );
-
+                    Err(_) => {
+                        error!("Banning replica {} because of failed health check", index);
                        // Don't leave a bad connection in the pool.
                        server.mark_bad();

-                        self.ban(&address, process_id);
+                        self.ban(address, shard);
                        continue;
                    }
                },
-
-                // Health check timed out.
-                Err(err) => {
-                    error!(
-                        "Banning instance {:?} because of health check timeout, {:?}",
-                        address, err
-                    );
+                // Health check never came back, database is really really down
+                Err(_) => {
+                    error!("Banning replica {} because of health check timeout", index);
                    // Don't leave a bad connection in the pool.
                    server.mark_bad();

-                    self.ban(&address, process_id);
+                    self.ban(address, shard);
                    continue;
                }
            }
        }

-        Err(Error::AllServersDown)
+        return Err(Error::AllServersDown);
    }

    /// Ban an address (i.e. replica). It no longer will serve
    /// traffic for any new transactions. Existing transactions on that replica
    /// will finish successfully or error out to the clients.
-    pub fn ban(&self, address: &Address, client_id: i32) {
+    pub fn ban(&self, address: &Address, shard: usize) {
        error!("Banning {:?}", address);
-        self.stats.client_ban_error(client_id, address.id);
-
        let now = chrono::offset::Utc::now().naive_utc();
        let mut guard = self.banlist.write();
-        guard[address.shard].insert(address.clone(), now);
+        guard[shard].insert(address.clone(), now);
    }

    /// Clear the replica to receive traffic again. Takes effect immediately
    /// for all new transactions.
-    pub fn _unban(&self, address: &Address) {
+    pub fn _unban(&self, address: &Address, shard: usize) {
        let mut guard = self.banlist.write();
-        guard[address.shard].remove(address);
+        guard[shard].remove(address);
    }

    /// Check if a replica can serve traffic. If all replicas are banned,
    /// we unban all of them. Better to try then not to.
-    pub fn is_banned(&self, address: &Address, role: Option<Role>) -> bool {
+    pub fn is_banned(&self, address: &Address, shard: usize, role: Option<Role>) -> bool {
        let replicas_available = match role {
-            Some(Role::Replica) => self.addresses[address.shard]
+            Some(Role::Replica) => self.addresses[shard]
                .iter()
                .filter(|addr| addr.role == Role::Replica)
                .count(),
-            None => self.addresses[address.shard].len(),
+            None => self.addresses[shard].len(),
            Some(Role::Primary) => return false, // Primary cannot be banned.
        };

@@ -482,17 +300,17 @@ impl ConnectionPool {
        let guard = self.banlist.read();

        // Everything is banned = nothing is banned.
-        if guard[address.shard].len() == replicas_available {
+        if guard[shard].len() == replicas_available {
            drop(guard);
            let mut guard = self.banlist.write();
-            guard[address.shard].clear();
+            guard[shard].clear();
            drop(guard);
            warn!("Unbanning all replicas.");
            return false;
        }

        // I expect this to miss 99.9999% of the time.
-        match guard[address.shard].get(address) {
+        match guard[shard].get(address) {
            Some(timestamp) => {
                let now = chrono::offset::Utc::now().naive_utc();
                let config = get_config();
@@ -502,7 +320,7 @@ impl ConnectionPool {
                    drop(guard);
                    warn!("Unbanning {:?}", address);
                    let mut guard = self.banlist.write();
-                    guard[address.shard].remove(address);
+                    guard[shard].remove(address);
                    false
                } else {
                    debug!("{:?} is banned", address);
@@ -517,18 +335,14 @@ impl ConnectionPool {
        }
    }

-    /// Get the number of configured shards.
    pub fn shards(&self) -> usize {
        self.databases.len()
    }

-    /// Get the number of servers (primary and replicas)
-    /// configured for a shard.
    pub fn servers(&self, shard: usize) -> usize {
        self.addresses[shard].len()
    }

-    /// Get the total number of servers (databases) we are connected to.
    pub fn databases(&self) -> usize {
        let mut databases = 0;
        for shard in 0..self.shards() {
@@ -537,22 +351,15 @@ impl ConnectionPool {
        databases
    }

-    /// Get pool state for a particular shard server as reported by bb8.
    pub fn pool_state(&self, shard: usize, server: usize) -> bb8::State {
        self.databases[shard][server].state()
    }

-    /// Get the address information for a shard server.
    pub fn address(&self, shard: usize, server: usize) -> &Address {
        &self.addresses[shard][server]
    }
-
-    pub fn server_info(&self) -> BytesMut {
-        self.server_info.clone()
-    }
 }

-/// Wrapper for the bb8 connection pool.
 pub struct ServerPool {
    address: Address,
    user: User,
@@ -586,21 +393,17 @@ impl ManageConnection for ServerPool {

    /// Attempts to create a new connection.
    async fn connect(&self) -> Result<Self::Connection, Self::Error> {
-        info!("Creating a new server connection {:?}", self.address);
-        let server_id = rand::random::<i32>();
-
-        self.stats.server_register(
-            server_id,
-            self.address.id,
-            self.address.name(),
-            self.address.pool_name.clone(),
-            self.address.username.clone(),
+        info!(
+            "Creating a new connection to {:?} using user {:?}",
+            self.address, self.user.name
        );
-        self.stats.server_login(server_id);

-        // Connect to the PostgreSQL server.
+        // Put a temporary process_id into the stats
+        // for server login.
+        let process_id = rand::random::<i32>();
+        self.stats.server_login(process_id);
+
        match Server::startup(
-            server_id,
            &self.address,
            &self.user,
            &self.database,
@@ -610,18 +413,20 @@ impl ManageConnection for ServerPool {
        .await
        {
            Ok(conn) => {
-                self.stats.server_idle(server_id);
+                // Remove the temporary process_id from the stats.
+                self.stats.server_disconnecting(process_id);
                Ok(conn)
            }
            Err(err) => {
-                self.stats.server_disconnecting(server_id);
+                // Remove the temporary process_id from the stats.
+                self.stats.server_disconnecting(process_id);
                Err(err)
            }
        }
    }

    /// Determines if the connection is still connected to the database.
-    async fn is_valid(&self, _conn: &mut Self::Connection) -> Result<(), Self::Error> {
+    async fn is_valid(&self, _conn: &mut PooledConnection<'_, Self>) -> Result<(), Self::Error> {
        Ok(())
    }

@@ -630,24 +435,3 @@ impl ManageConnection for ServerPool {
        conn.is_bad()
    }
 }
-
-/// Get the connection pool
-pub fn get_pool(db: &str, user: &str) -> Option<ConnectionPool> {
-    match get_all_pools().get(&PoolIdentifier::new(&db, &user)) {
-        Some(pool) => Some(pool.clone()),
-        None => None,
-    }
-}
-
-/// Get a pointer to all configured pools.
-pub fn get_all_pools() -> HashMap<PoolIdentifier, ConnectionPool> {
-    return (*(*POOLS.load())).clone();
-}
-
-/// How many total servers we have in the config.
-pub fn get_number_of_addresses() -> usize {
-    get_all_pools()
-        .iter()
-        .map(|(_, pool)| pool.databases())
-        .sum()
-}
--- a/src/prometheus.rs
+++ b/src/prometheus.rs
@@ -1,210 +0,0 @@
-use hyper::service::{make_service_fn, service_fn};
-use hyper::{Body, Method, Request, Response, Server, StatusCode};
-use log::{error, info, warn};
-use phf::phf_map;
-use std::collections::HashMap;
-use std::fmt;
-use std::net::SocketAddr;
-
-use crate::config::Address;
-use crate::pool::get_all_pools;
-use crate::stats::get_address_stats;
-
-struct MetricHelpType {
-    help: &'static str,
-    ty: &'static str,
-}
-
-// reference for metric types: https://prometheus.io/docs/concepts/metric_types/
-// counters only increase
-// gauges can arbitrarily increase or decrease
-static METRIC_HELP_AND_TYPES_LOOKUP: phf::Map<&'static str, MetricHelpType> = phf_map! {
-    "total_query_count" => MetricHelpType {
-        help: "Number of queries sent by all clients",
-        ty: "counter",
-    },
-    "total_query_time" => MetricHelpType {
-        help: "Total amount of time for queries to execute",
-        ty: "counter",
-    },
-    "total_received" => MetricHelpType {
-        help: "Number of bytes received from the server",
-        ty: "counter",
-    },
-    "total_sent" => MetricHelpType {
-        help: "Number of bytes sent to the server",
-        ty: "counter",
-    },
-    "total_xact_count" => MetricHelpType {
-        help: "Total number of transactions started by the client",
-        ty: "counter",
-    },
-    "total_xact_time" => MetricHelpType {
-        help: "Total amount of time for all transactions to execute",
-        ty: "counter",
-    },
-    "total_wait_time" => MetricHelpType {
-        help: "Total time client waited for a server connection",
-        ty: "counter",
-    },
-    "avg_query_count" => MetricHelpType {
-        help: "Average of total_query_count every 15 seconds",
-        ty: "gauge",
-    },
-    "avg_query_time" => MetricHelpType {
-        help: "Average time taken for queries to execute every 15 seconds",
-        ty: "gauge",
-    },
-    "avg_recv" => MetricHelpType {
-        help: "Average of total_received bytes every 15 seconds",
-        ty: "gauge",
-    },
-    "avg_sent" => MetricHelpType {
-        help: "Average of total_sent bytes every 15 seconds",
-        ty: "gauge",
-    },
-    "avg_xact_count" => MetricHelpType {
-        help: "Average of total_xact_count every 15 seconds",
-        ty: "gauge",
-    },
-    "avg_xact_time" => MetricHelpType {
-        help: "Average of total_xact_time every 15 seconds",
-        ty: "gauge",
-    },
-    "avg_wait_time" => MetricHelpType {
-        help: "Average of total_wait_time every 15 seconds",
-        ty: "gauge",
-    },
-    "maxwait_us" => MetricHelpType {
-        help: "The time a client waited for a server connection in microseconds",
-        ty: "gauge",
-    },
-    "maxwait" => MetricHelpType {
-        help: "The time a client waited for a server connection in seconds",
-        ty: "gauge",
-    },
-    "cl_waiting" => MetricHelpType {
-        help: "How many clients are waiting for a connection from the pool",
-        ty: "gauge",
-    },
-    "cl_active" => MetricHelpType {
-        help: "How many clients are actively communicating with a server",
-        ty: "gauge",
-    },
-    "cl_idle" => MetricHelpType {
-        help: "How many clients are idle",
-        ty: "gauge",
-    },
-    "sv_idle" => MetricHelpType {
-        help: "How many server connections are idle",
-        ty: "gauge",
-    },
-    "sv_active" => MetricHelpType {
-        help: "How many server connections are actively communicating with a client",
-        ty: "gauge",
-    },
-    "sv_login" => MetricHelpType {
-        help: "How many server connections are currently being created",
-        ty: "gauge",
-    },
-    "sv_tested" => MetricHelpType {
-        help: "How many server connections are currently waiting on a health check to succeed",
-        ty: "gauge",
-    },
-};
-
-struct PrometheusMetric {
-    name: String,
-    help: String,
-    ty: String,
-    labels: HashMap<&'static str, String>,
-    value: i64,
-}
-
-impl fmt::Display for PrometheusMetric {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let formatted_labels = self
-            .labels
-            .iter()
-            .map(|(key, value)| format!("{}=\"{}\"", key, value))
-            .collect::<Vec<_>>()
-            .join(",");
-        write!(
-            f,
-            "# HELP {name} {help}\n# TYPE {name} {ty}\n{name}{{{formatted_labels}}} {value}\n",
-            name = format_args!("pgcat_{}", self.name),
-            help = self.help,
-            ty = self.ty,
-            formatted_labels = formatted_labels,
-            value = self.value
-        )
-    }
-}
-
-impl PrometheusMetric {
-    fn new(address: &Address, name: &str, value: i64) -> Option<PrometheusMetric> {
-        let mut labels = HashMap::new();
-        labels.insert("host", address.host.clone());
-        labels.insert("shard", address.shard.to_string());
-        labels.insert("role", address.role.to_string());
-        labels.insert("database", address.database.to_string());
-
-        METRIC_HELP_AND_TYPES_LOOKUP
-            .get(name)
-            .map(|metric| PrometheusMetric {
-                name: name.to_owned(),
-                help: metric.help.to_owned(),
-                ty: metric.ty.to_owned(),
-                labels,
-                value,
-            })
-    }
-}
-
-async fn prometheus_stats(request: Request<Body>) -> Result<Response<Body>, hyper::http::Error> {
-    match (request.method(), request.uri().path()) {
-        (&Method::GET, "/metrics") => {
-            let stats: HashMap<usize, HashMap<String, i64>> = get_address_stats();
-
-            let mut lines = Vec::new();
-            for (_, pool) in get_all_pools() {
-                for shard in 0..pool.shards() {
-                    for server in 0..pool.servers(shard) {
-                        let address = pool.address(shard, server);
-                        if let Some(address_stats) = stats.get(&address.id) {
-                            for (key, value) in address_stats.iter() {
-                                if let Some(prometheus_metric) =
-                                    PrometheusMetric::new(address, key, *value)
-                                {
-                                    lines.push(prometheus_metric.to_string());
-                                } else {
-                                    warn!("Metric {} not implemented for {}", key, address.name());
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            Response::builder()
-                .header("content-type", "text/plain; version=0.0.4")
-                .body(lines.join("\n").into())
-        }
-        _ => Response::builder()
-            .status(StatusCode::NOT_FOUND)
-            .body("".into()),
-    }
-}
-
-pub async fn start_metric_server(http_addr: SocketAddr) {
-    let http_service_factory =
-        make_service_fn(|_conn| async { Ok::<_, hyper::Error>(service_fn(prometheus_stats)) });
-    let server = Server::bind(&http_addr.into()).serve(http_service_factory);
-    info!(
-        "Exposing prometheus metrics on http://{}/metrics.",
-        http_addr
-    );
-    if let Err(e) = server.await {
-        error!("Failed to run HTTP server: {}.", e);
-    }
-}
--- a/src/query_router.rs
+++ b/src/query_router.rs
@@ -1,3 +1,5 @@
+use crate::config::{get_config, Role};
+use crate::sharding::{Sharder, ShardingFunction};
 /// Route queries automatically based on explicitely requested
 /// or implied query characteristics.
 use bytes::{Buf, BytesMut};
@@ -8,22 +10,14 @@ use sqlparser::ast::Statement::{Query, StartTransaction};
 use sqlparser::dialect::PostgreSqlDialect;
 use sqlparser::parser::Parser;

-use crate::config::Role;
-use crate::pool::PoolSettings;
-use crate::sharding::Sharder;
-
-/// Regexes used to parse custom commands.
-const CUSTOM_SQL_REGEXES: [&str; 7] = [
+const CUSTOM_SQL_REGEXES: [&str; 5] = [
    r"(?i)^ *SET SHARDING KEY TO '?([0-9]+)'? *;? *$",
-    r"(?i)^ *SET SHARD TO '?([0-9]+|ANY)'? *;? *$",
+    r"(?i)^ *SET SHARD TO '?([0-9]+)'? *;? *$",
    r"(?i)^ *SHOW SHARD *;? *$",
    r"(?i)^ *SET SERVER ROLE TO '(PRIMARY|REPLICA|ANY|AUTO|DEFAULT)' *;? *$",
    r"(?i)^ *SHOW SERVER ROLE *;? *$",
-    r"(?i)^ *SET PRIMARY READS TO '?(on|off|default)'? *;? *$",
-    r"(?i)^ *SHOW PRIMARY READS *;? *$",
 ];

-/// Custom commands.
 #[derive(PartialEq, Debug)]
 pub enum Command {
    SetShardingKey,
@@ -31,37 +25,39 @@ pub enum Command {
    ShowShard,
    SetServerRole,
    ShowServerRole,
-    SetPrimaryReads,
-    ShowPrimaryReads,
 }

-/// Quickly test for match when a query is received.
+// Quick test
 static CUSTOM_SQL_REGEX_SET: OnceCell<RegexSet> = OnceCell::new();

-// Get the value inside the custom command.
+// Capture value
 static CUSTOM_SQL_REGEX_LIST: OnceCell<Vec<Regex>> = OnceCell::new();

-/// The query router.
 pub struct QueryRouter {
-    /// Which shard we should be talking to right now.
+    // By default, queries go here, unless we have better information
+    // about what the client wants.
+    default_server_role: Option<Role>,
+
+    // Number of shards in the cluster.
+    shards: usize,
+
+    // Which shard we should be talking to right now.
    active_shard: Option<usize>,

-    /// Which server should we be talking to.
+    // Should we be talking to a primary or a replica?
    active_role: Option<Role>,

-    /// Should we try to parse queries to route them to replicas or primary automatically
-    query_parser_enabled: bool,
-
-    /// Include the primary into the replica pool for reads.
+    // Include the primary into the replica pool?
    primary_reads_enabled: bool,

-    /// Pool configuration.
-    pool_settings: PoolSettings,
+    // Should we try to parse queries?
+    query_parser_enabled: bool,
+
+    // Which sharding function are we using?
+    sharding_function: ShardingFunction,
 }

 impl QueryRouter {
-    /// One-time initialization of regexes
-    /// that parse our custom SQL protocol.
    pub fn setup() -> bool {
        let set = match RegexSet::new(&CUSTOM_SQL_REGEXES) {
            Ok(rgx) => rgx,
@@ -76,7 +72,10 @@ impl QueryRouter {
            .map(|rgx| Regex::new(rgx).unwrap())
            .collect();

-        assert_eq!(list.len(), set.len());
+        // Impossible
+        if list.len() != set.len() {
+            return false;
+        }

        match CUSTOM_SQL_REGEX_LIST.set(list) {
            Ok(_) => true,
@@ -89,28 +88,38 @@ impl QueryRouter {
        }
    }

-    /// Create a new instance of the query router.
-    /// Each client gets its own.
    pub fn new() -> QueryRouter {
-        QueryRouter {
-            active_shard: None,
-            active_role: None,
-            query_parser_enabled: false,
-            primary_reads_enabled: false,
-            pool_settings: PoolSettings::default(),
-        }
-    }
+        let config = get_config();

-    /// Pool settings can change because of a config reload.
-    pub fn update_pool_settings(&mut self, pool_settings: PoolSettings) {
-        self.pool_settings = pool_settings;
+        let default_server_role = match config.query_router.default_role.as_ref() {
+            "any" => None,
+            "primary" => Some(Role::Primary),
+            "replica" => Some(Role::Replica),
+            _ => unreachable!(),
+        };
+
+        let sharding_function = match config.query_router.sharding_function.as_ref() {
+            "pg_bigint_hash" => ShardingFunction::PgBigintHash,
+            "sha1" => ShardingFunction::Sha1,
+            _ => unreachable!(),
+        };
+
+        QueryRouter {
+            default_server_role: default_server_role,
+            shards: config.shards.len(),
+
+            active_role: default_server_role,
+            active_shard: None,
+            primary_reads_enabled: config.query_router.primary_reads_enabled,
+            query_parser_enabled: config.query_router.query_parser_enabled,
+            sharding_function,
+        }
    }

    /// Try to parse a command and execute it.
    pub fn try_execute_command(&mut self, mut buf: BytesMut) -> Option<(Command, String)> {
        let code = buf.get_u8() as char;

-        // Only simple protocol supported for commands.
        if code != 'Q' {
            return None;
        }
@@ -130,10 +139,7 @@ impl QueryRouter {

        let matches: Vec<_> = regex_set.matches(&query).into_iter().collect();

-        // This is not a custom query, try to infer which
-        // server it'll go to if the query parser is enabled.
        if matches.len() != 1 {
-            debug!("Regular query, not a command");
            return None;
        }

@@ -143,21 +149,17 @@ impl QueryRouter {
            2 => Command::ShowShard,
            3 => Command::SetServerRole,
            4 => Command::ShowServerRole,
-            5 => Command::SetPrimaryReads,
-            6 => Command::ShowPrimaryReads,
            _ => unreachable!(),
        };

        let mut value = match command {
-            Command::SetShardingKey
-            | Command::SetShard
-            | Command::SetServerRole
-            | Command::SetPrimaryReads => {
+            Command::SetShardingKey | Command::SetShard | Command::SetServerRole => {
                // Capture value. I know this re-runs the regex engine, but I haven't
                // figured out a better way just yet. I think I can write a single Regex
                // that matches all 5 custom SQL patterns, but maybe that's not very legible?
                //
-                // I think this is faster than running the Regex engine 5 times.
+                // I think this is faster than running the Regex engine 5 times, so
+                // this is a strong maybe for me so far.
                match regex_list[matches[0]].captures(&query) {
                    Some(captures) => match captures.get(1) {
                        Some(value) => value.as_str().to_string(),
@@ -169,8 +171,8 @@ impl QueryRouter {

            Command::ShowShard => self.shard().to_string(),
            Command::ShowServerRole => match self.active_role {
-                Some(Role::Primary) => Role::Primary.to_string(),
-                Some(Role::Replica) => Role::Replica.to_string(),
+                Some(Role::Primary) => String::from("primary"),
+                Some(Role::Replica) => String::from("replica"),
                None => {
                    if self.query_parser_enabled {
                        String::from("auto")
@@ -179,29 +181,18 @@ impl QueryRouter {
                    }
                }
            },
-
-            Command::ShowPrimaryReads => match self.primary_reads_enabled {
-                true => String::from("on"),
-                false => String::from("off"),
-            },
        };

        match command {
            Command::SetShardingKey => {
-                let sharder = Sharder::new(
-                    self.pool_settings.shards,
-                    self.pool_settings.sharding_function,
-                );
+                let sharder = Sharder::new(self.shards, self.sharding_function);
                let shard = sharder.shard(value.parse::<i64>().unwrap());
                self.active_shard = Some(shard);
                value = shard.to_string();
            }

            Command::SetShard => {
-                self.active_shard = match value.to_ascii_uppercase().as_ref() {
-                    "ANY" => Some(rand::random::<usize>() % self.pool_settings.shards),
-                    _ => Some(value.parse::<usize>().unwrap()),
-                };
+                self.active_shard = Some(value.parse::<usize>().unwrap());
            }

            Command::SetServerRole => {
@@ -227,8 +218,9 @@ impl QueryRouter {
                    }

                    "default" => {
-                        self.active_role = self.pool_settings.default_role;
-                        self.query_parser_enabled = self.query_parser_enabled;
+                        // TODO: reset query parser to default here.
+                        self.active_role = self.default_server_role;
+                        self.query_parser_enabled = get_config().query_router.query_parser_enabled;
                        self.active_role
                    }

@@ -236,19 +228,6 @@ impl QueryRouter {
                };
            }

-            Command::SetPrimaryReads => {
-                if value == "on" {
-                    debug!("Setting primary reads to on");
-                    self.primary_reads_enabled = true;
-                } else if value == "off" {
-                    debug!("Setting primary reads to off");
-                    self.primary_reads_enabled = false;
-                } else if value == "default" {
-                    debug!("Setting primary reads to default");
-                    self.primary_reads_enabled = self.pool_settings.primary_reads_enabled;
-                }
-            }
-
            _ => (),
        }

@@ -257,20 +236,16 @@ impl QueryRouter {

    /// Try to infer which server to connect to based on the contents of the query.
    pub fn infer_role(&mut self, mut buf: BytesMut) -> bool {
-        debug!("Inferring role");
-
        let code = buf.get_u8() as char;
        let len = buf.get_i32() as usize;

        let query = match code {
-            // Query
            'Q' => {
                let query = String::from_utf8_lossy(&buf[..len - 5]).to_string();
                debug!("Query: '{}'", query);
                query
            }

-            // Parse (prepared statement)
            'P' => {
                let mut start = 0;
                let mut end;
@@ -293,7 +268,6 @@ impl QueryRouter {

                query.replace("$", "") // Remove placeholders turning them into "values"
            }
-
            _ => return false,
        };

@@ -345,23 +319,28 @@ impl QueryRouter {
        }
    }

-    pub fn set_shard(&mut self, shard: usize) {
-        self.active_shard = Some(shard);
+    /// Reset the router back to defaults.
+    /// This must be called at the end of every transaction in transaction mode.
+    pub fn _reset(&mut self) {
+        self.active_role = self.default_server_role;
+        self.active_shard = None;
    }

    /// Should we attempt to parse queries?
-    #[allow(dead_code)]
    pub fn query_parser_enabled(&self) -> bool {
        self.query_parser_enabled
    }
+
+    #[allow(dead_code)]
+    pub fn toggle_primary_reads(&mut self, value: bool) {
+        self.primary_reads_enabled = value;
+    }
 }

 #[cfg(test)]
 mod test {
    use super::*;
-    use crate::config::PoolMode;
    use crate::messages::simple_query;
-    use crate::sharding::ShardingFunction;
    use bytes::BufMut;

    #[test]
@@ -378,8 +357,7 @@ mod test {
        let mut qr = QueryRouter::new();
        assert!(qr.try_execute_command(simple_query("SET SERVER ROLE TO 'auto'")) != None);
        assert_eq!(qr.query_parser_enabled(), true);
-
-        assert!(qr.try_execute_command(simple_query("SET PRIMARY READS TO off")) != None);
+        qr.toggle_primary_reads(false);

        let queries = vec![
            simple_query("SELECT * FROM items WHERE id = 5"),
@@ -420,7 +398,7 @@ mod test {
        QueryRouter::setup();
        let mut qr = QueryRouter::new();
        let query = simple_query("SELECT * FROM items WHERE id = 5");
-        assert!(qr.try_execute_command(simple_query("SET PRIMARY READS TO on")) != None);
+        qr.toggle_primary_reads(true);

        assert!(qr.infer_role(query));
        assert_eq!(qr.role(), None);
@@ -431,7 +409,7 @@ mod test {
        QueryRouter::setup();
        let mut qr = QueryRouter::new();
        qr.try_execute_command(simple_query("SET SERVER ROLE TO 'auto'"));
-        assert!(qr.try_execute_command(simple_query("SET PRIMARY READS TO off")) != None);
+        qr.toggle_primary_reads(false);

        let prepared_stmt = BytesMut::from(
            &b"WITH t AS (SELECT * FROM items WHERE name = $1) SELECT * FROM t WHERE id = $2\0"[..],
@@ -460,10 +438,6 @@ mod test {
            "SET SERVER ROLE TO 'any'",
            "SET SERVER ROLE TO 'auto'",
            "SHOW SERVER ROLE",
-            "SET PRIMARY READS TO 'on'",
-            "SET PRIMARY READS TO 'off'",
-            "SET PRIMARY READS TO 'default'",
-            "SHOW PRIMARY READS",
            // Lower case
            "set sharding key to '1'",
            "set shard to '1'",
@@ -473,13 +447,9 @@ mod test {
            "set server role to 'any'",
            "set server role to 'auto'",
            "show server role",
-            "set primary reads to 'on'",
-            "set primary reads to 'OFF'",
-            "set primary reads to 'deFaUlt'",
            // No quotes
            "SET SHARDING KEY TO 11235",
            "SET SHARD TO 15",
-            "SET PRIMARY READS TO off",
            // Spaces and semicolon
            "  SET SHARDING KEY TO 11235  ; ",
            "  SET SHARD TO 15;   ",
@@ -487,23 +457,18 @@ mod test {
            " SET SERVER ROLE TO 'primary';   ",
            "    SET SERVER ROLE TO 'primary'  ; ",
            "  SET SERVER ROLE TO 'primary'  ;",
-            "  SET PRIMARY READS TO 'off'    ;",
        ];

        // Which regexes it'll match to in the list
        let matches = [
-            0, 1, 2, 3, 3, 3, 3, 4, 5, 5, 5, 6, 0, 1, 2, 3, 3, 3, 3, 4, 5, 5, 5, 0, 1, 5, 0, 1, 0,
-            3, 3, 3, 5,
+            0, 1, 2, 3, 3, 3, 3, 4, 0, 1, 2, 3, 3, 3, 3, 4, 0, 1, 0, 1, 0, 3, 3, 3,
        ];

        let list = CUSTOM_SQL_REGEX_LIST.get().unwrap();
        let set = CUSTOM_SQL_REGEX_SET.get().unwrap();

        for (i, test) in tests.iter().enumerate() {
-            if !list[matches[i]].is_match(test) {
-                println!("{} does not match {}", test, list[matches[i]]);
-                assert!(false);
-            }
+            assert!(list[matches[i]].is_match(test));
            assert_eq!(set.matches(test).into_iter().collect::<Vec<_>>().len(), 1);
        }

@@ -526,9 +491,9 @@ mod test {
        let query = simple_query("SET SHARDING KEY TO 13");
        assert_eq!(
            qr.try_execute_command(query),
-            Some((Command::SetShardingKey, String::from("0")))
+            Some((Command::SetShardingKey, String::from("1")))
        );
-        assert_eq!(qr.shard(), 0);
+        assert_eq!(qr.shard(), 1);

        // SetShard
        let query = simple_query("SET SHARD TO '1'");
@@ -572,26 +537,6 @@ mod test {
                Some((Command::ShowServerRole, String::from(*role)))
            );
        }
-
-        let primary_reads = ["on", "off", "default"];
-        let primary_reads_enabled = ["on", "off", "on"];
-
-        for (idx, primary_reads) in primary_reads.iter().enumerate() {
-            assert_eq!(
-                qr.try_execute_command(simple_query(&format!(
-                    "SET PRIMARY READS TO {}",
-                    primary_reads
-                ))),
-                Some((Command::SetPrimaryReads, String::from(*primary_reads)))
-            );
-            assert_eq!(
-                qr.try_execute_command(simple_query("SHOW PRIMARY READS")),
-                Some((
-                    Command::ShowPrimaryReads,
-                    String::from(primary_reads_enabled[idx])
-                ))
-            );
-        }
    }

    #[test]
@@ -599,7 +544,7 @@ mod test {
        QueryRouter::setup();
        let mut qr = QueryRouter::new();
        let query = simple_query("SET SERVER ROLE TO 'auto'");
-        assert!(qr.try_execute_command(simple_query("SET PRIMARY READS TO off")) != None);
+        qr.toggle_primary_reads(false);

        assert!(qr.try_execute_command(query) != None);
        assert!(qr.query_parser_enabled());
@@ -616,42 +561,6 @@ mod test {
        assert!(qr.query_parser_enabled());
        let query = simple_query("SET SERVER ROLE TO 'default'");
        assert!(qr.try_execute_command(query) != None);
-        assert!(qr.query_parser_enabled());
-    }
-
-    #[test]
-    fn test_update_from_pool_settings() {
-        QueryRouter::setup();
-
-        let pool_settings = PoolSettings {
-            pool_mode: PoolMode::Transaction,
-            shards: 0,
-            user: crate::config::User::default(),
-            default_role: Some(Role::Replica),
-            query_parser_enabled: true,
-            primary_reads_enabled: false,
-            sharding_function: ShardingFunction::PgBigintHash,
-        };
-        let mut qr = QueryRouter::new();
-        assert_eq!(qr.active_role, None);
-        assert_eq!(qr.active_shard, None);
-        assert_eq!(qr.query_parser_enabled, false);
-        assert_eq!(qr.primary_reads_enabled, false);
-
-        // Internal state must not be changed due to this, only defaults
-        qr.update_pool_settings(pool_settings.clone());
-
-        assert_eq!(qr.active_role, None);
-        assert_eq!(qr.active_shard, None);
-        assert_eq!(qr.query_parser_enabled, false);
-        assert_eq!(qr.primary_reads_enabled, false);
-
-        let q1 = simple_query("SET SERVER ROLE TO 'primary'");
-        assert!(qr.try_execute_command(q1) != None);
-        assert_eq!(qr.active_role.unwrap(), Role::Primary);
-
-        let q2 = simple_query("SET SERVER ROLE TO 'default'");
-        assert!(qr.try_execute_command(q2) != None);
-        assert_eq!(qr.active_role.unwrap(), pool_settings.clone().default_role);
+        assert!(!qr.query_parser_enabled());
    }
 }
--- a/src/scram.rs
+++ b/src/scram.rs
@@ -1,320 +0,0 @@
-// SCRAM-SHA-256 authentication. Heavily inspired by
-// https://github.com/sfackler/rust-postgres/
-// SASL implementation.
-
-use bytes::BytesMut;
-use hmac::{Hmac, Mac};
-use rand::{self, Rng};
-use sha2::digest::FixedOutput;
-use sha2::{Digest, Sha256};
-
-use std::fmt::Write;
-
-use crate::constants::*;
-use crate::errors::Error;
-
-/// Normalize a password string. Postgres
-/// passwords don't have to be UTF-8.
-fn normalize(pass: &[u8]) -> Vec<u8> {
-    let pass = match std::str::from_utf8(pass) {
-        Ok(pass) => pass,
-        Err(_) => return pass.to_vec(),
-    };
-
-    match stringprep::saslprep(pass) {
-        Ok(pass) => pass.into_owned().into_bytes(),
-        Err(_) => pass.as_bytes().to_vec(),
-    }
-}
-
-/// Keep the SASL state through the exchange.
-/// It takes 3 messages to complete the authentication.
-pub struct ScramSha256 {
-    password: String,
-    salted_password: [u8; 32],
-    auth_message: String,
-    message: BytesMut,
-    nonce: String,
-}
-
-impl ScramSha256 {
-    /// Create the Scram state from a password. It'll automatically
-    /// generate a nonce.
-    pub fn new(password: &str) -> ScramSha256 {
-        let mut rng = rand::thread_rng();
-        let nonce = (0..NONCE_LENGTH)
-            .map(|_| {
-                let mut v = rng.gen_range(0x21u8..0x7e);
-                if v == 0x2c {
-                    v = 0x7e
-                }
-                v as char
-            })
-            .collect::<String>();
-
-        Self::from_nonce(password, &nonce)
-    }
-
-    /// Used for testing.
-    pub fn from_nonce(password: &str, nonce: &str) -> ScramSha256 {
-        let message = BytesMut::from(&format!("{}n=,r={}", "n,,", nonce).as_bytes()[..]);
-
-        ScramSha256 {
-            password: password.to_string(),
-            nonce: String::from(nonce),
-            message,
-            salted_password: [0u8; 32],
-            auth_message: String::new(),
-        }
-    }
-
-    /// Get the current state of the SASL authentication.
-    pub fn message(&mut self) -> BytesMut {
-        self.message.clone()
-    }
-
-    /// Update the state with message received from server.
-    pub fn update(&mut self, message: &BytesMut) -> Result<BytesMut, Error> {
-        let server_message = Message::parse(message)?;
-
-        if !server_message.nonce.starts_with(&self.nonce) {
-            return Err(Error::ProtocolSyncError);
-        }
-
-        let salt = match base64::decode(&server_message.salt) {
-            Ok(salt) => salt,
-            Err(_) => return Err(Error::ProtocolSyncError),
-        };
-
-        let salted_password = Self::hi(
-            &normalize(&self.password.as_bytes()[..]),
-            &salt,
-            server_message.iterations,
-        );
-
-        // Save for verification of final server message.
-        self.salted_password = salted_password;
-
-        let mut hmac = match Hmac::<Sha256>::new_from_slice(&salted_password) {
-            Ok(hmac) => hmac,
-            Err(_) => return Err(Error::ServerError),
-        };
-
-        hmac.update(b"Client Key");
-
-        let client_key = hmac.finalize().into_bytes();
-
-        let mut hash = Sha256::default();
-        hash.update(client_key.as_slice());
-
-        let stored_key = hash.finalize_fixed();
-        let mut cbind_input = vec![];
-        cbind_input.extend("n,,".as_bytes());
-
-        let cbind_input = base64::encode(&cbind_input);
-
-        self.message.clear();
-
-        // Start writing the client reply.
-        match write!(
-            &mut self.message,
-            "c={},r={}",
-            cbind_input, server_message.nonce
-        ) {
-            Ok(_) => (),
-            Err(_) => return Err(Error::ServerError),
-        };
-
-        let auth_message = format!(
-            "n=,r={},{},{}",
-            self.nonce,
-            String::from_utf8_lossy(&message[..]),
-            String::from_utf8_lossy(&self.message[..])
-        );
-
-        let mut hmac = match Hmac::<Sha256>::new_from_slice(&stored_key) {
-            Ok(hmac) => hmac,
-            Err(_) => return Err(Error::ServerError),
-        };
-        hmac.update(auth_message.as_bytes());
-
-        // Save the auth message for server final message verification.
-        self.auth_message = auth_message;
-
-        let client_signature = hmac.finalize().into_bytes();
-
-        // Sign the client proof.
-        let mut client_proof = client_key;
-        for (proof, signature) in client_proof.iter_mut().zip(client_signature) {
-            *proof ^= signature;
-        }
-
-        match write!(&mut self.message, ",p={}", base64::encode(&*client_proof)) {
-            Ok(_) => (),
-            Err(_) => return Err(Error::ServerError),
-        };
-
-        Ok(self.message.clone())
-    }
-
-    /// Verify final server message.
-    pub fn finish(&mut self, message: &BytesMut) -> Result<(), Error> {
-        let final_message = FinalMessage::parse(message)?;
-
-        let verifier = match base64::decode(&final_message.value) {
-            Ok(verifier) => verifier,
-            Err(_) => return Err(Error::ProtocolSyncError),
-        };
-
-        let mut hmac = match Hmac::<Sha256>::new_from_slice(&self.salted_password) {
-            Ok(hmac) => hmac,
-            Err(_) => return Err(Error::ServerError),
-        };
-        hmac.update(b"Server Key");
-        let server_key = hmac.finalize().into_bytes();
-
-        let mut hmac = match Hmac::<Sha256>::new_from_slice(&server_key) {
-            Ok(hmac) => hmac,
-            Err(_) => return Err(Error::ServerError),
-        };
-        hmac.update(self.auth_message.as_bytes());
-
-        match hmac.verify_slice(&verifier) {
-            Ok(_) => Ok(()),
-            Err(_) => return Err(Error::ServerError),
-        }
-    }
-
-    /// Hash the password with the salt i-times.
-    fn hi(str: &[u8], salt: &[u8], i: u32) -> [u8; 32] {
-        let mut hmac =
-            Hmac::<Sha256>::new_from_slice(str).expect("HMAC is able to accept all key sizes");
-        hmac.update(salt);
-        hmac.update(&[0, 0, 0, 1]);
-        let mut prev = hmac.finalize().into_bytes();
-
-        let mut hi = prev;
-
-        for _ in 1..i {
-            let mut hmac = Hmac::<Sha256>::new_from_slice(str).expect("already checked above");
-            hmac.update(&prev);
-            prev = hmac.finalize().into_bytes();
-
-            for (hi, prev) in hi.iter_mut().zip(prev) {
-                *hi ^= prev;
-            }
-        }
-
-        hi.into()
-    }
-}
-
-/// Parse the server challenge.
-struct Message {
-    nonce: String,
-    salt: String,
-    iterations: u32,
-}
-
-impl Message {
-    /// Parse the server SASL challenge.
-    fn parse(message: &BytesMut) -> Result<Message, Error> {
-        let parts = String::from_utf8_lossy(&message[..])
-            .split(",")
-            .map(|s| s.to_string())
-            .collect::<Vec<String>>();
-
-        if parts.len() != 3 {
-            return Err(Error::ProtocolSyncError);
-        }
-
-        let nonce = str::replace(&parts[0], "r=", "");
-        let salt = str::replace(&parts[1], "s=", "");
-        let iterations = match str::replace(&parts[2], "i=", "").parse::<u32>() {
-            Ok(iterations) => iterations,
-            Err(_) => return Err(Error::ProtocolSyncError),
-        };
-
-        Ok(Message {
-            nonce,
-            salt,
-            iterations,
-        })
-    }
-}
-
-/// Parse server final validation message.
-struct FinalMessage {
-    value: String,
-}
-
-impl FinalMessage {
-    /// Parse the server final validation message.
-    pub fn parse(message: &BytesMut) -> Result<FinalMessage, Error> {
-        if !message.starts_with(b"v=") || message.len() < 4 {
-            return Err(Error::ProtocolSyncError);
-        }
-
-        Ok(FinalMessage {
-            value: String::from_utf8_lossy(&message[2..]).to_string(),
-        })
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn parse_server_first_message() {
-        let message = BytesMut::from(
-            &"r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,i=4096".as_bytes()[..],
-        );
-        let message = Message::parse(&message).unwrap();
-        assert_eq!(message.nonce, "fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j");
-        assert_eq!(message.salt, "QSXCR+Q6sek8bf92");
-        assert_eq!(message.iterations, 4096);
-    }
-
-    #[test]
-    fn parse_server_last_message() {
-        let f = FinalMessage::parse(&BytesMut::from(
-            &"v=U+ppxD5XUKtradnv8e2MkeupiA8FU87Sg8CXzXHDAzw".as_bytes()[..],
-        ))
-        .unwrap();
-        assert_eq!(
-            f.value,
-            "U+ppxD5XUKtradnv8e2MkeupiA8FU87Sg8CXzXHDAzw".to_string()
-        );
-    }
-
-    // recorded auth exchange from psql
-    #[test]
-    fn exchange() {
-        let password = "foobar";
-        let nonce = "9IZ2O01zb9IgiIZ1WJ/zgpJB";
-
-        let client_first = "n,,n=,r=9IZ2O01zb9IgiIZ1WJ/zgpJB";
-        let server_first =
-            "r=9IZ2O01zb9IgiIZ1WJ/zgpJBjx/oIRLs02gGSHcw1KEty3eY,s=fs3IXBy7U7+IvVjZ,i\
-             =4096";
-        let client_final =
-            "c=biws,r=9IZ2O01zb9IgiIZ1WJ/zgpJBjx/oIRLs02gGSHcw1KEty3eY,p=AmNKosjJzS3\
-             1NTlQYNs5BTeQjdHdk7lOflDo5re2an8=";
-        let server_final = "v=U+ppxD5XUKtradnv8e2MkeupiA8FU87Sg8CXzXHDAzw=";
-
-        let mut scram = ScramSha256::from_nonce(password, nonce);
-
-        let message = scram.message();
-        assert_eq!(std::str::from_utf8(&message).unwrap(), client_first);
-
-        let result = scram
-            .update(&BytesMut::from(&server_first.as_bytes()[..]))
-            .unwrap();
-        assert_eq!(std::str::from_utf8(&result).unwrap(), client_final);
-
-        scram
-            .finish(&BytesMut::from(&server_final.as_bytes()[..]))
-            .unwrap();
-    }
-}
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,9 +1,7 @@
-/// Implementation of the PostgreSQL server (database) protocol.
-/// Here we are pretending to the a Postgres client.
 use bytes::{Buf, BufMut, BytesMut};
-use log::{debug, error, info, trace, warn};
-use std::io::Read;
-use std::time::SystemTime;
+///! Implementation of the PostgreSQL server (database) protocol.
+///! Here we are pretending to the a Postgres client.
+use log::{debug, error, info, trace};
 use tokio::io::{AsyncReadExt, BufReader};
 use tokio::net::{
    tcp::{OwnedReadHalf, OwnedWriteHalf},
@@ -14,67 +12,54 @@ use crate::config::{Address, User};
 use crate::constants::*;
 use crate::errors::Error;
 use crate::messages::*;
-use crate::pool::ClientServerMap;
-use crate::scram::ScramSha256;
 use crate::stats::Reporter;
+use crate::ClientServerMap;

 /// Server state.
 pub struct Server {
-    server_id: i32,
-
-    /// Server host, e.g. localhost,
-    /// port, e.g. 5432, and role, e.g. primary or replica.
+    // Server host, e.g. localhost,
+    // port, e.g. 5432, and role, e.g. primary or replica.
    address: Address,

-    /// Buffered read socket.
+    // Buffered read socket.
    read: BufReader<OwnedReadHalf>,

-    /// Unbuffered write socket (our client code buffers).
+    // Unbuffered write socket (our client code buffers).
    write: OwnedWriteHalf,

-    /// Our server response buffer. We buffer data before we give it to the client.
+    // Our server response buffer. We buffer data before we give it to the client.
    buffer: BytesMut,

-    /// Server information the server sent us over on startup.
+    // Server information the server sent us over on startup.
    server_info: BytesMut,

-    /// Backend id and secret key used for query cancellation.
+    // Backend id and secret key used for query cancellation.
    process_id: i32,
    secret_key: i32,

-    /// Is the server inside a transaction or idle.
+    // Is the server inside a transaction or idle.
    in_transaction: bool,

-    /// Is there more data for the client to read.
+    // Is there more data for the client to read.
    data_available: bool,

-    /// Is the server broken? We'll remote it from the pool if so.
+    // Is the server broken? We'll remote it from the pool if so.
    bad: bool,

-    /// If server connection requires a DISCARD ALL before checkin
-    needs_cleanup: bool,
-
-    /// Mapping of clients and servers used for query cancellation.
+    // Mapping of clients and servers used for query cancellation.
    client_server_map: ClientServerMap,

-    /// Server connected at.
+    // Server connected at.
    connected_at: chrono::naive::NaiveDateTime,

-    /// Reports various metrics, e.g. data sent & received.
+    // Reports various metrics, e.g. data sent & received.
    stats: Reporter,
-
-    /// Application name using the server at the moment.
-    application_name: String,
-
-    // Last time that a successful server send or response happened
-    last_activity: SystemTime,
 }

 impl Server {
    /// Pretend to be the Postgres client and connect to the server given host, port and credentials.
    /// Perform the authentication and return the server in a ready for query state.
    pub async fn startup(
-        server_id: i32,
        address: &Address,
        user: &User,
        database: &str,
@@ -82,7 +67,7 @@ impl Server {
        stats: Reporter,
    ) -> Result<Server, Error> {
        let mut stream =
-            match TcpStream::connect(&format!("{}:{}", &address.host, address.port)).await {
+            match TcpStream::connect(&format!("{}:{}", &address.host, &address.port)).await {
                Ok(stream) => stream,
                Err(err) => {
                    error!("Could not connect to server: {}", err);
@@ -92,8 +77,8 @@ impl Server {

        trace!("Sending StartupMessage");

-        // StartupMessage
-        startup(&mut stream, &user.username, database).await?;
+        // Send the startup packet telling the server we're a normal Postgres client.
+        startup(&mut stream, &user.name, database).await?;

        let mut server_info = BytesMut::new();
        let mut process_id: i32 = 0;
@@ -101,8 +86,6 @@ impl Server {

        // We'll be handling multiple packets, but they will all be structured the same.
        // We'll loop here until this exchange is complete.
-        let mut scram = ScramSha256::new(&user.password);
-
        loop {
            let code = match stream.read_u8().await {
                Ok(code) => code as char,
@@ -138,97 +121,12 @@ impl Server {
                                Err(_) => return Err(Error::SocketError),
                            };

-                            md5_password(&mut stream, &user.username, &user.password, &salt[..])
+                            md5_password(&mut stream, &user.name, &user.password, &salt[..])
                                .await?;
                        }

                        AUTHENTICATION_SUCCESSFUL => (),

-                        SASL => {
-                            debug!("Starting SASL authentication");
-                            let sasl_len = (len - 8) as usize;
-                            let mut sasl_auth = vec![0u8; sasl_len];
-
-                            match stream.read_exact(&mut sasl_auth).await {
-                                Ok(_) => (),
-                                Err(_) => return Err(Error::SocketError),
-                            };
-
-                            let sasl_type = String::from_utf8_lossy(&sasl_auth[..sasl_len - 2]);
-
-                            if sasl_type == SCRAM_SHA_256 {
-                                debug!("Using {}", SCRAM_SHA_256);
-
-                                // Generate client message.
-                                let sasl_response = scram.message();
-
-                                // SASLInitialResponse (F)
-                                let mut res = BytesMut::new();
-                                res.put_u8(b'p');
-
-                                // length + String length + length + length of sasl response
-                                res.put_i32(
-                                    4 // i32 size
-                                        + SCRAM_SHA_256.len() as i32 // length of SASL version string,
-                                        + 1 // Null terminator for the SASL version string,
-                                        + 4 // i32 size
-                                        + sasl_response.len() as i32, // length of SASL response
-                                );
-
-                                res.put_slice(&format!("{}\0", SCRAM_SHA_256).as_bytes()[..]);
-                                res.put_i32(sasl_response.len() as i32);
-                                res.put(sasl_response);
-
-                                write_all(&mut stream, res).await?;
-                            } else {
-                                error!("Unsupported SCRAM version: {}", sasl_type);
-                                return Err(Error::ServerError);
-                            }
-                        }
-
-                        SASL_CONTINUE => {
-                            trace!("Continuing SASL");
-
-                            let mut sasl_data = vec![0u8; (len - 8) as usize];
-
-                            match stream.read_exact(&mut sasl_data).await {
-                                Ok(_) => (),
-                                Err(_) => return Err(Error::SocketError),
-                            };
-
-                            let msg = BytesMut::from(&sasl_data[..]);
-                            let sasl_response = scram.update(&msg)?;
-
-                            // SASLResponse
-                            let mut res = BytesMut::new();
-                            res.put_u8(b'p');
-                            res.put_i32(4 + sasl_response.len() as i32);
-                            res.put(sasl_response);
-
-                            write_all(&mut stream, res).await?;
-                        }
-
-                        SASL_FINAL => {
-                            trace!("Final SASL");
-
-                            let mut sasl_final = vec![0u8; len as usize - 8];
-                            match stream.read_exact(&mut sasl_final).await {
-                                Ok(_) => (),
-                                Err(_) => return Err(Error::SocketError),
-                            };
-
-                            match scram.finish(&BytesMut::from(&sasl_final[..])) {
-                                Ok(_) => {
-                                    debug!("SASL authentication successful");
-                                }
-
-                                Err(err) => {
-                                    debug!("SASL authentication failed");
-                                    return Err(err);
-                                }
-                            };
-                        }
-
                        _ => {
                            error!("Unsupported authentication mechanism: {}", auth_code);
                            return Err(Error::ServerError);
@@ -289,7 +187,7 @@ impl Server {
                // BackendKeyData
                'K' => {
                    // The frontend must save these values if it wishes to be able to issue CancelRequest messages later.
-                    // See: <https://www.postgresql.org/docs/12/protocol-message-formats.html>.
+                    // See: https://www.postgresql.org/docs/12/protocol-message-formats.html
                    process_id = match stream.read_i32().await {
                        Ok(id) => id,
                        Err(_) => return Err(Error::SocketError),
@@ -310,31 +208,25 @@ impl Server {
                        Err(_) => return Err(Error::SocketError),
                    };

+                    // This is the last step in the client-server connection setup,
+                    // and indicates the server is ready for to query it.
                    let (read, write) = stream.into_split();

-                    let mut server = Server {
+                    return Ok(Server {
                        address: address.clone(),
                        read: BufReader::new(read),
                        write: write,
                        buffer: BytesMut::with_capacity(8196),
                        server_info: server_info,
-                        server_id: server_id,
                        process_id: process_id,
                        secret_key: secret_key,
                        in_transaction: false,
                        data_available: false,
                        bad: false,
-                        needs_cleanup: false,
                        client_server_map: client_server_map,
                        connected_at: chrono::offset::Utc::now().naive_utc(),
                        stats: stats,
-                        application_name: String::new(),
-                        last_activity: SystemTime::now(),
-                    };
-
-                    server.set_name("pgcat").await?;
-
-                    return Ok(server);
+                    });
                }

                // We have an unexpected message from the server during this exchange.
@@ -351,7 +243,7 @@ impl Server {
    /// Uses a separate connection that's not part of the connection pool.
    pub async fn cancel(
        host: &str,
-        port: u16,
+        port: &str,
        process_id: i32,
        secret_key: i32,
    ) -> Result<(), Error> {
@@ -376,14 +268,10 @@ impl Server {

    /// Send messages to the server from the client.
    pub async fn send(&mut self, messages: BytesMut) -> Result<(), Error> {
-        self.stats.data_sent(messages.len(), self.server_id);
+        self.stats.data_sent(messages.len());

        match write_all_half(&mut self.write, messages).await {
-            Ok(_) => {
-                // Successfully sent to server
-                self.last_activity = SystemTime::now();
-                Ok(())
-            }
+            Ok(_) => Ok(()),
            Err(err) => {
                error!("Terminating server because of: {:?}", err);
                self.bad = true;
@@ -430,7 +318,7 @@ impl Server {
                            self.in_transaction = false;
                        }

-                        // Some error occurred, the transaction was rolled back.
+                        // Some error occured, the transaction was rolled back.
                        'E' => {
                            self.in_transaction = true;
                        }
@@ -448,35 +336,13 @@ impl Server {
                    break;
                }

-                // CommandComplete
-                'C' => {
-                    let mut command_tag = String::new();
-                    match message.reader().read_to_string(&mut command_tag) {
-                        Ok(_) => {
-                            // Non-exhaustive list of commands that are likely to change session variables/resources
-                            // which can leak between clients. This is a best effort to block bad clients
-                            // from poisoning a transaction-mode pool by setting inappropriate session variables
-                            match command_tag.as_str() {
-                                "SET\0" | "PREPARE\0" => {
-                                    debug!("Server connection marked for clean up");
-                                    self.needs_cleanup = true;
-                                }
-                                _ => (),
-                            }
-                        }
-
-                        Err(err) => {
-                            warn!("Encountered an error while parsing CommandTag {}", err);
-                        }
-                    }
-                }
-
                // DataRow
                'D' => {
                    // More data is available after this message, this is not the end of the reply.
                    self.data_available = true;

-                    // Don't flush yet, the more we buffer, the faster this goes...up to a limit.
+                    // Don't flush yet, the more we buffer, the faster this goes...
+                    // up to a limit of course.
                    if self.buffer.len() >= 8196 {
                        break;
                    }
@@ -508,14 +374,11 @@ impl Server {
        let bytes = self.buffer.clone();

        // Keep track of how much data we got from the server for stats.
-        self.stats.data_received(bytes.len(), self.server_id);
+        self.stats.data_received(bytes.len());

        // Clear the buffer for next query.
        self.buffer.clear();

-        // Successfully received data from server
-        self.last_activity = SystemTime::now();
-
        // Pass the data back to the client.
        Ok(bytes)
    }
@@ -546,7 +409,7 @@ impl Server {

    /// Indicate that this server connection cannot be re-used and must be discarded.
    pub fn mark_bad(&mut self) {
-        error!("Server {:?} marked bad", self.address);
+        error!("Server marked bad");
        self.bad = true;
    }

@@ -559,7 +422,7 @@ impl Server {
                self.process_id,
                self.secret_key,
                self.address.host.clone(),
-                self.address.port,
+                self.address.port.clone(),
            ),
        );
    }
@@ -583,48 +446,12 @@ impl Server {
        Ok(())
    }

-    /// Perform any necessary cleanup before putting the server
-    /// connection back in the pool
-    pub async fn checkin_cleanup(&mut self) -> Result<(), Error> {
-        // Client disconnected with an open transaction on the server connection.
-        // Pgbouncer behavior is to close the server connection but that can cause
-        // server connection thrashing if clients repeatedly do this.
-        // Instead, we ROLLBACK that transaction before putting the connection back in the pool
-        if self.in_transaction() {
-            warn!("Server returned while still in transaction, rolling back transaction");
-            self.query("ROLLBACK").await?;
-        }
-
-        // Client disconnected but it perfromed session-altering operations such as
-        // SET statement_timeout to 1 or create a prepared statement. We clear that
-        // to avoid leaking state between clients. For performance reasons we only
-        // send `DISCARD ALL` if we think the session is altered instead of just sending
-        // it before each checkin.
-        if self.needs_cleanup {
-            warn!("Server returned with session state altered, discarding state");
-            self.query("DISCARD ALL").await?;
-            self.needs_cleanup = false;
-        }
-
-        return Ok(());
-    }
-
    /// A shorthand for `SET application_name = $1`.
+    #[allow(dead_code)]
    pub async fn set_name(&mut self, name: &str) -> Result<(), Error> {
-        if self.application_name != name {
-            self.application_name = name.to_string();
-            // We don't want `SET application_name` to mark the server connection
-            // as needing cleanup
-            let needs_cleanup_before = self.needs_cleanup;
-
-            let result = Ok(self
-                .query(&format!("SET application_name = '{}'", name))
-                .await?);
-            self.needs_cleanup = needs_cleanup_before;
-            return result;
-        } else {
-            Ok(())
-        }
+        Ok(self
+            .query(&format!("SET application_name = '{}'", name))
+            .await?)
    }

    /// Get the servers address.
@@ -633,20 +460,8 @@ impl Server {
        self.address.clone()
    }

-    /// Get the server connection identifier
-    /// Used to uniquely identify connection in statistics
-    pub fn server_id(&self) -> i32 {
-        self.server_id
-    }
-
-    // Get server's latest response timestamp
-    pub fn last_activity(&self) -> SystemTime {
-        self.last_activity
-    }
-
-    // Marks a connection as needing DISCARD ALL at checkin
-    pub fn mark_dirty(&mut self) {
-        self.needs_cleanup = true;
+    pub fn process_id(&self) -> i32 {
+        self.process_id
    }
 }

@@ -655,7 +470,7 @@ impl Drop for Server {
    /// the socket is in non-blocking mode, so it may not be ready
    /// for a write.
    fn drop(&mut self) {
-        self.stats.server_disconnecting(self.server_id);
+        self.stats.server_disconnecting(self.process_id());

        let mut bytes = BytesMut::with_capacity(4);
        bytes.put_u8(b'X');
@@ -663,18 +478,16 @@ impl Drop for Server {

        match self.write.try_write(&bytes) {
            Ok(_) => (),
-            Err(_) => debug!("Dirty shutdown"),
+            Err(_) => (),
        };

-        // Should not matter.
        self.bad = true;

        let now = chrono::offset::Utc::now().naive_utc();
        let duration = now - self.connected_at;

        info!(
-            "Server connection closed {:?}, session duration: {}",
-            self.address,
+            "Server connection closed, session duration: {}",
            crate::format_duration(&duration)
        );
    }
--- a/src/sharding.rs
+++ b/src/sharding.rs
@@ -1,39 +1,20 @@
-use serde_derive::{Deserialize, Serialize};
-/// Implements various sharding functions.
 use sha1::{Digest, Sha1};

-/// See: <https://github.com/postgres/postgres/blob/27b77ecf9f4d5be211900eda54d8155ada50d696/src/include/catalog/partition.h#L20>.
+// https://github.com/postgres/postgres/blob/27b77ecf9f4d5be211900eda54d8155ada50d696/src/include/catalog/partition.h#L20
 const PARTITION_HASH_SEED: u64 = 0x7A5B22367996DCFD;

-/// The sharding functions we support.
-#[derive(Debug, PartialEq, Copy, Clone, Serialize, Deserialize, Hash, std::cmp::Eq)]
+#[derive(Debug, PartialEq, Copy, Clone)]
 pub enum ShardingFunction {
-    #[serde(alias = "pg_bigint_hash", alias = "PgBigintHash")]
    PgBigintHash,
-    #[serde(alias = "sha1", alias = "Sha1")]
    Sha1,
 }

-impl ToString for ShardingFunction {
-    fn to_string(&self) -> String {
-        match *self {
-            ShardingFunction::PgBigintHash => "pg_bigint_hash".to_string(),
-            ShardingFunction::Sha1 => "sha1".to_string(),
-        }
-    }
-}
-
-/// The sharder.
 pub struct Sharder {
-    /// Number of shards in the cluster.
    shards: usize,
-
-    /// The sharding function in use.
    sharding_function: ShardingFunction,
 }

 impl Sharder {
-    /// Create new instance of the sharder.
    pub fn new(shards: usize, sharding_function: ShardingFunction) -> Sharder {
        Sharder {
            shards,
@@ -41,7 +22,6 @@ impl Sharder {
        }
    }

-    /// Compute the shard given sharding key.
    pub fn shard(&self, key: i64) -> usize {
        match self.sharding_function {
            ShardingFunction::PgBigintHash => self.pg_bigint_hash(key),
@@ -51,7 +31,7 @@ impl Sharder {

    /// Hash function used by Postgres to determine which partition
    /// to put the row in when using HASH(column) partitioning.
-    /// Source: <https://github.com/postgres/postgres/blob/27b77ecf9f4d5be211900eda54d8155ada50d696/src/common/hashfn.c#L631>.
+    /// Source: https://github.com/postgres/postgres/blob/27b77ecf9f4d5be211900eda54d8155ada50d696/src/common/hashfn.c#L631
    /// Supports only 1 bigint at the moment, but we can add more later.
    fn pg_bigint_hash(&self, key: i64) -> usize {
        let mut lohalf = key as u32;
@@ -139,7 +119,6 @@ impl Sharder {
        a
    }

-    #[inline]
    fn pg_u32_hash(k: u32) -> u64 {
        let mut a: u32 = 0x9e3779b9 as u32 + std::mem::size_of::<u32>() as u32 + 3923095 as u32;
        let mut b = a;
--- a/src/stats.rs
+++ b/src/stats.rs
--- a/src/tls.rs
+++ b/src/tls.rs
@@ -1,57 +0,0 @@
-// Stream wrapper.
-
-use rustls_pemfile::{certs, rsa_private_keys};
-use std::path::Path;
-use std::sync::Arc;
-use tokio_rustls::rustls::{self, Certificate, PrivateKey};
-use tokio_rustls::TlsAcceptor;
-
-use crate::config::get_config;
-use crate::errors::Error;
-
-// TLS
-pub fn load_certs(path: &Path) -> std::io::Result<Vec<Certificate>> {
-    certs(&mut std::io::BufReader::new(std::fs::File::open(path)?))
-        .map_err(|_| std::io::Error::new(std::io::ErrorKind::InvalidInput, "invalid cert"))
-        .map(|mut certs| certs.drain(..).map(Certificate).collect())
-}
-
-pub fn load_keys(path: &Path) -> std::io::Result<Vec<PrivateKey>> {
-    rsa_private_keys(&mut std::io::BufReader::new(std::fs::File::open(path)?))
-        .map_err(|_| std::io::Error::new(std::io::ErrorKind::InvalidInput, "invalid key"))
-        .map(|mut keys| keys.drain(..).map(PrivateKey).collect())
-}
-
-pub struct Tls {
-    pub acceptor: TlsAcceptor,
-}
-
-impl Tls {
-    pub fn new() -> Result<Self, Error> {
-        let config = get_config();
-
-        let certs = match load_certs(&Path::new(&config.general.tls_certificate.unwrap())) {
-            Ok(certs) => certs,
-            Err(_) => return Err(Error::TlsError),
-        };
-
-        let mut keys = match load_keys(&Path::new(&config.general.tls_private_key.unwrap())) {
-            Ok(keys) => keys,
-            Err(_) => return Err(Error::TlsError),
-        };
-
-        let config = match rustls::ServerConfig::builder()
-            .with_safe_defaults()
-            .with_no_client_auth()
-            .with_single_cert(certs, keys.remove(0))
-            .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))
-        {
-            Ok(c) => c,
-            Err(_) => return Err(Error::TlsError),
-        };
-
-        Ok(Tls {
-            acceptor: TlsAcceptor::from(Arc::new(config)),
-        })
-    }
-}
--- a/src/userlist.json
+++ b/src/userlist.json
@@ -0,0 +1,4 @@
+{
+  "sven": "clear_text_password",
+  "sharding_user": "sharding_user"
+}
--- a/src/userlist.rs
+++ b/src/userlist.rs
@@ -0,0 +1,57 @@
+use arc_swap::{ArcSwap, Guard};
+use log::{error};
+use once_cell::sync::Lazy;
+use tokio::fs::File;
+use tokio::io::AsyncReadExt;
+
+use std::collections::{HashMap};
+use std::sync::Arc;
+
+use crate::errors::Error;
+
+pub type UserList = HashMap<String, String>;
+static USER_LIST: Lazy<ArcSwap<UserList>> = Lazy::new(|| ArcSwap::from_pointee(HashMap::new()));
+
+pub fn get_user_list() -> Guard<Arc<UserList>> {
+    USER_LIST.load()
+}
+
+/// Parse the user list.
+pub async fn parse(path: &str) -> Result<(), Error> {
+    let mut contents = String::new();
+    let mut file = match File::open(path).await {
+        Ok(file) => file,
+        Err(err) => {
+            error!("Could not open '{}': {}", path, err.to_string());
+            return Err(Error::BadConfig);
+        }
+    };
+
+    match file.read_to_string(&mut contents).await {
+        Ok(_) => (),
+        Err(err) => {
+            error!("Could not read config file: {}", err.to_string());
+            return Err(Error::BadConfig);
+        }
+    };
+
+    let map: HashMap<String, String> = serde_json::from_str(&contents).expect("JSON was not well-formatted");
+
+
+
+    USER_LIST.store(Arc::new(map.clone()));
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_config() {
+        parse("userlist.json").await.unwrap();
+        assert_eq!(get_user_list()["sven"], "clear_text_password");
+        assert_eq!(get_user_list()["sharding_user"], "sharding_user");
+    }
+}
--- a/tests/docker/Dockerfile
+++ b/tests/docker/Dockerfile
@@ -1,5 +0,0 @@
-FROM rust:bullseye
-
-RUN apt-get update && apt-get install llvm-11 psmisc postgresql-contrib postgresql-client ruby ruby-dev libpq-dev python3 python3-pip lcov sudo curl -y
-RUN cargo install cargo-binutils rustfilt
-RUN rustup component add llvm-tools-preview
--- a/tests/docker/docker-compose.yml
+++ b/tests/docker/docker-compose.yml
@@ -1,47 +0,0 @@
-version: "3"
-services:
-  pg1:
-    image: postgres:14
-    network_mode: "service:main"
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_DB: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_HOST_AUTH_METHOD: scram-sha-256
-    command: ["postgres", "-c", "shared_preload_libraries=pg_stat_statements", "-c", "pg_stat_statements.track=all", "-p", "5432"]
-  pg2:
-    image: postgres:14
-    network_mode: "service:main"
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_DB: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_HOST_AUTH_METHOD: scram-sha-256
-    command: ["postgres", "-c", "shared_preload_libraries=pg_stat_statements", "-c", "pg_stat_statements.track=all", "-p", "7432"]
-  pg3:
-    image: postgres:14
-    network_mode: "service:main"
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_DB: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_HOST_AUTH_METHOD: scram-sha-256
-    command: ["postgres", "-c", "shared_preload_libraries=pg_stat_statements", "-c", "pg_stat_statements.track=all", "-p", "8432"]
-  pg4:
-    image: postgres:14
-    network_mode: "service:main"
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_DB: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_HOST_AUTH_METHOD: scram-sha-256
-    command: ["postgres", "-c", "shared_preload_libraries=pg_stat_statements", "-c", "pg_stat_statements.track=all", "-p", "9432"]
-  main:
-    build: .
-    command: ["bash", "/app/tests/docker/run.sh"]
-    environment:
-      RUSTFLAGS: "-C instrument-coverage"
-      LLVM_PROFILE_FILE: "pgcat-%m.profraw"
-    volumes:
-      - ../../:/app/
-      - /app/target/
--- a/tests/docker/run.sh
+++ b/tests/docker/run.sh
@@ -1,21 +0,0 @@
-#!/bin/bash
-
-rm /app/*.profraw || true
-rm /app/pgcat.profdata || true
-rm -rf /app/cov || true
-
-cd /app/
-
-cargo build
-cargo test --tests
-
-bash .circleci/run_tests.sh
-
-rust-profdata merge -sparse pgcat-*.profraw -o pgcat.profdata
-
-rust-cov export -ignore-filename-regex="rustc|registry" -Xdemangler=rustfilt -instr-profile=pgcat.profdata --object ./target/debug/pgcat --format lcov > ./lcov.info
-
-genhtml lcov.info --output-directory cov --prefix $(pwd)
-
-rm /app/*.profraw
-rm /app/pgcat.profdata
--- a/tests/pgbench/simple.sql
+++ b/tests/pgbench/simple.sql
@@ -1,39 +0,0 @@
-
-- \setrandom aid 1 :naccounts
-\set aid random(1, 100000)
-- \setrandom bid 1 :nbranches
-\set bid random(1, 100000)
-- \setrandom tid 1 :ntellers
-\set tid random(1, 100000)
-- \setrandom delta -5000 5000
-\set delta random(-5000,5000)
-
-\set shard random(0, 2)
-
-SET SHARD TO :shard;
-
-SET SERVER ROLE TO 'auto';
-
-BEGIN;
-
-UPDATE pgbench_accounts SET abalance = abalance + :delta WHERE aid = :aid;
-
-SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
-
-UPDATE pgbench_tellers SET tbalance = tbalance + :delta WHERE tid = :tid;
-
-UPDATE pgbench_branches SET bbalance = bbalance + :delta WHERE bid = :bid;
-
-INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);
-
-END;
-
-SET SHARDING KEY TO :aid;
-
-- Read load balancing
-SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
-
-SET SERVER ROLE TO 'replica';
-
-- Read load balancing
-SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
--- a/tests/python/requirements.txt
+++ b/tests/python/requirements.txt
@@ -1,2 +1 @@
 psycopg2==2.9.3
-psutil==5.9.1
--- a/tests/python/tests.py
+++ b/tests/python/tests.py
@@ -1,257 +1,11 @@
-from typing import Tuple
 import psycopg2
-import psutil
-import os
-import signal
-import time

-SHUTDOWN_TIMEOUT = 5
+conn = psycopg2.connect("postgres://random:password@127.0.0.1:6432/db")
+cur = conn.cursor()

-PGCAT_HOST = "127.0.0.1"
-PGCAT_PORT = "6432"
+cur.execute("SELECT 1");
+res = cur.fetchall()

+print(res)

-def pgcat_start():
-    pg_cat_send_signal(signal.SIGTERM)
-    os.system("./target/debug/pgcat .circleci/pgcat.toml &")
-    time.sleep(2)
-
-
-def pg_cat_send_signal(signal: signal.Signals):
-    try:
-        for proc in psutil.process_iter(["pid", "name"]):
-            if "pgcat" == proc.name():
-                os.kill(proc.pid, signal)
-    except Exception as e:
-        # The process can be gone when we send this signal
-        print(e)
-
-    if signal == signal.SIGTERM:
-        # Returns 0 if pgcat process exists
-        time.sleep(2)
-        if not os.system('pgrep pgcat'):
-            raise Exception("pgcat not closed after SIGTERM")
-
-
-def connect_db(
-    autocommit: bool = True,
-    admin: bool = False,
-) -> Tuple[psycopg2.extensions.connection, psycopg2.extensions.cursor]:
-
-    if admin:
-        user = "admin_user"
-        password = "admin_pass"
-        db = "pgcat"
-    else:
-        user = "sharding_user"
-        password = "sharding_user"
-        db = "sharded_db"
-
-    conn = psycopg2.connect(
-        f"postgres://{user}:{password}@{PGCAT_HOST}:{PGCAT_PORT}/{db}?application_name=testing_pgcat",
-        connect_timeout=2,
-    )
-    conn.autocommit = autocommit
-    cur = conn.cursor()
-
-    return (conn, cur)
-
-
-def cleanup_conn(conn: psycopg2.extensions.connection, cur: psycopg2.extensions.cursor):
-    cur.close()
-    conn.close()
-
-
-def test_normal_db_access():
-    conn, cur = connect_db(autocommit=False)
-    cur.execute("SELECT 1")
-    res = cur.fetchall()
-    print(res)
-    cleanup_conn(conn, cur)
-
-
-def test_admin_db_access():
-    conn, cur = connect_db(admin=True)
-
-    cur.execute("SHOW POOLS")
-    res = cur.fetchall()
-    print(res)
-    cleanup_conn(conn, cur)
-
-
-def test_shutdown_logic():
-
-    # - - - - - - - - - - - - - - - - - -
-    # NO ACTIVE QUERIES SIGINT HANDLING
-
-    # Start pgcat
-    pgcat_start()
-
-    # Create client connection and send query (not in transaction)
-    conn, cur = connect_db()
-
-    cur.execute("BEGIN;")
-    cur.execute("SELECT 1;")
-    cur.execute("COMMIT;")
-
-    # Send sigint to pgcat
-    pg_cat_send_signal(signal.SIGINT)
-    time.sleep(1)
-
-    # Check that any new queries fail after sigint since server should close with no active transactions
-    try:
-        cur.execute("SELECT 1;")
-    except psycopg2.OperationalError as e:
-        pass
-    else:
-        # Fail if query execution succeeded
-        raise Exception("Server not closed after sigint")
-
-    cleanup_conn(conn, cur)
-    pg_cat_send_signal(signal.SIGTERM)
-
-    # - - - - - - - - - - - - - - - - - -
-    # HANDLE TRANSACTION WITH SIGINT
-
-    # Start pgcat
-    pgcat_start()
-
-    # Create client connection and begin transaction
-    conn, cur = connect_db()
-
-    cur.execute("BEGIN;")
-    cur.execute("SELECT 1;")
-
-    # Send sigint to pgcat while still in transaction
-    pg_cat_send_signal(signal.SIGINT)
-    time.sleep(1)
-
-    # Check that any new queries succeed after sigint since server should still allow transaction to complete
-    try:
-        cur.execute("SELECT 1;")
-    except psycopg2.OperationalError as e:
-        # Fail if query fails since server closed
-        raise Exception("Server closed while in transaction", e.pgerror)
-
-    cleanup_conn(conn, cur)
-    pg_cat_send_signal(signal.SIGTERM)
-
-    # - - - - - - - - - - - - - - - - - -
-    # NO NEW NON-ADMIN CONNECTIONS DURING SHUTDOWN
-    # Start pgcat
-    pgcat_start()
-
-    # Create client connection and begin transaction
-    transaction_conn, transaction_cur = connect_db()
-
-    transaction_cur.execute("BEGIN;")
-    transaction_cur.execute("SELECT 1;")
-
-    # Send sigint to pgcat while still in transaction
-    pg_cat_send_signal(signal.SIGINT)
-    time.sleep(1)
-
-    start = time.perf_counter()
-    try:
-        conn, cur = connect_db()
-        cur.execute("SELECT 1;")
-        cleanup_conn(conn, cur)
-    except psycopg2.OperationalError as e:
-        time_taken = time.perf_counter() - start
-        if time_taken > 0.1:
-            raise Exception(
-                "Failed to reject connection within 0.1 seconds, got", time_taken, "seconds")
-        pass
-    else:
-        raise Exception("Able connect to database during shutdown")
-
-    cleanup_conn(transaction_conn, transaction_cur)
-    pg_cat_send_signal(signal.SIGTERM)
-
-    # - - - - - - - - - - - - - - - - - -
-    # ALLOW NEW ADMIN CONNECTIONS DURING SHUTDOWN
-    # Start pgcat
-    pgcat_start()
-
-    # Create client connection and begin transaction
-    transaction_conn, transaction_cur = connect_db()
-
-    transaction_cur.execute("BEGIN;")
-    transaction_cur.execute("SELECT 1;")
-
-    # Send sigint to pgcat while still in transaction
-    pg_cat_send_signal(signal.SIGINT)
-    time.sleep(1)
-
-    try:
-        conn, cur = connect_db(admin=True)
-        cur.execute("SHOW DATABASES;")
-        cleanup_conn(conn, cur)
-    except psycopg2.OperationalError as e:
-        raise Exception(e)
-
-    cleanup_conn(transaction_conn, transaction_cur)
-    pg_cat_send_signal(signal.SIGTERM)
-
-    # - - - - - - - - - - - - - - - - - -
-    # ADMIN CONNECTIONS CONTINUING TO WORK AFTER SHUTDOWN
-    # Start pgcat
-    pgcat_start()
-
-    # Create client connection and begin transaction
-    transaction_conn, transaction_cur = connect_db()
-    transaction_cur.execute("BEGIN;")
-    transaction_cur.execute("SELECT 1;")
-
-    admin_conn, admin_cur = connect_db(admin=True)
-    admin_cur.execute("SHOW DATABASES;")
-
-    # Send sigint to pgcat while still in transaction
-    pg_cat_send_signal(signal.SIGINT)
-    time.sleep(1)
-
-    try:
-        admin_cur.execute("SHOW DATABASES;")
-    except psycopg2.OperationalError as e:
-        raise Exception("Could not execute admin command:", e)
-
-    cleanup_conn(transaction_conn, transaction_cur)
-    cleanup_conn(admin_conn, admin_cur)
-    pg_cat_send_signal(signal.SIGTERM)
-
-    # - - - - - - - - - - - - - - - - - -
-    # HANDLE SHUTDOWN TIMEOUT WITH SIGINT
-
-    # Start pgcat
-    pgcat_start()
-
-    # Create client connection and begin transaction, which should prevent server shutdown unless shutdown timeout is reached
-    conn, cur = connect_db()
-
-    cur.execute("BEGIN;")
-    cur.execute("SELECT 1;")
-
-    # Send sigint to pgcat while still in transaction
-    pg_cat_send_signal(signal.SIGINT)
-
-    # pgcat shutdown timeout is set to SHUTDOWN_TIMEOUT seconds, so we sleep for SHUTDOWN_TIMEOUT + 1 seconds
-    time.sleep(SHUTDOWN_TIMEOUT + 1)
-
-    # Check that any new queries succeed after sigint since server should still allow transaction to complete
-    try:
-        cur.execute("SELECT 1;")
-    except psycopg2.OperationalError as e:
-        pass
-    else:
-        # Fail if query execution succeeded
-        raise Exception("Server not closed after sigint and expected timeout")
-
-    cleanup_conn(conn, cur)
-    pg_cat_send_signal(signal.SIGTERM)
-
-    # - - - - - - - - - - - - - - - - - -
-
-
-test_normal_db_access()
-test_admin_db_access()
-test_shutdown_logic()
+# conn.commit()
--- a/tests/ruby/.ruby-version
+++ b/tests/ruby/.ruby-version
@@ -1,2 +1 @@
-3.0.0
-
+2.7.1
--- a/tests/ruby/Gemfile
+++ b/tests/ruby/Gemfile
@@ -1,8 +1,4 @@
 source "https://rubygems.org"

 gem "pg"
-gem "toml"
-gem "rspec"
-gem "rubocop"
-gem "toxiproxy"
 gem "activerecord"
--- a/tests/ruby/Gemfile.lock
+++ b/tests/ruby/Gemfile.lock
@@ -1,74 +1,30 @@
 GEM
  remote: https://rubygems.org/
  specs:
-    activemodel (7.0.3.1)
-      activesupport (= 7.0.3.1)
-    activerecord (7.0.3.1)
-      activemodel (= 7.0.3.1)
-      activesupport (= 7.0.3.1)
-    activesupport (7.0.3.1)
+    activemodel (7.0.2.2)
+      activesupport (= 7.0.2.2)
+    activerecord (7.0.2.2)
+      activemodel (= 7.0.2.2)
+      activesupport (= 7.0.2.2)
+    activesupport (7.0.2.2)
      concurrent-ruby (~> 1.0, >= 1.0.2)
      i18n (>= 1.6, < 2)
      minitest (>= 5.1)
      tzinfo (~> 2.0)
-    ast (2.4.2)
-    concurrent-ruby (1.1.10)
-    diff-lcs (1.5.0)
-    i18n (1.11.0)
+    concurrent-ruby (1.1.9)
+    i18n (1.10.0)
      concurrent-ruby (~> 1.0)
-    minitest (5.16.2)
-    parallel (1.22.1)
-    parser (3.1.2.0)
-      ast (~> 2.4.1)
-    parslet (2.0.0)
+    minitest (5.15.0)
    pg (1.3.2)
-    rainbow (3.1.1)
-    regexp_parser (2.3.1)
-    rexml (3.2.5)
-    rspec (3.11.0)
-      rspec-core (~> 3.11.0)
-      rspec-expectations (~> 3.11.0)
-      rspec-mocks (~> 3.11.0)
-    rspec-core (3.11.0)
-      rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-mocks (3.11.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-support (3.11.0)
-    rubocop (1.29.0)
-      parallel (~> 1.10)
-      parser (>= 3.1.0.0)
-      rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.17.0, < 2.0)
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.17.0)
-      parser (>= 3.1.1.0)
-    ruby-progressbar (1.11.0)
-    toml (0.3.0)
-      parslet (>= 1.8.0, < 3.0.0)
-    toxiproxy (2.0.1)
    tzinfo (2.0.4)
      concurrent-ruby (~> 1.0)
-    unicode-display_width (2.1.0)

 PLATFORMS
-  aarch64-linux
-  arm64-darwin-21
  x86_64-linux

 DEPENDENCIES
  activerecord
  pg
-  rspec
-  rubocop
-  toml
-  toxiproxy

 BUNDLED WITH
-   2.3.21
+   2.3.7
--- a/tests/ruby/admin_spec.rb
+++ b/tests/ruby/admin_spec.rb
@@ -1,289 +0,0 @@
-# frozen_string_literal: true
-require 'uri'
-require_relative 'spec_helper'
-
-describe "Admin" do
-  let(:processes) { Helpers::Pgcat.single_instance_setup("sharded_db", 10) }
-  let(:pgcat_conn_str) { processes.pgcat.connection_string("sharded_db", "sharding_user") }
-
-  after do
-    processes.all_databases.map(&:reset)
-    processes.pgcat.shutdown
-  end
-
-  describe "SHOW STATS" do
-    context "clients connect and make one query" do
-      it "updates *_query_time and *_wait_time" do
-        connection = PG::connect("#{pgcat_conn_str}?application_name=one_query")
-        connection.async_exec("SELECT pg_sleep(0.25)")
-        connection.async_exec("SELECT pg_sleep(0.25)")
-        connection.async_exec("SELECT pg_sleep(0.25)")
-        connection.close
-
-        # wait for averages to be calculated, we shouldn't do this too often
-        sleep(15.5)
-        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-        results = admin_conn.async_exec("SHOW STATS")[0]
-        admin_conn.close
-        expect(results["total_query_time"].to_i).to be_within(200).of(750)
-        expect(results["avg_query_time"].to_i).to_not eq(0)
-
-        expect(results["total_wait_time"].to_i).to_not eq(0)
-        expect(results["avg_wait_time"].to_i).to_not eq(0)
-      end
-    end
-  end
-
-  describe "SHOW POOLS" do
-    context "bad credentials" do
-      it "does not change any stats" do
-        bad_passsword_url = URI(pgcat_conn_str)
-        bad_passsword_url.password = "wrong"
-        expect { PG::connect("#{bad_passsword_url.to_s}?application_name=bad_password") }.to raise_error(PG::ConnectionBad)
-
-        sleep(1)
-        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_idle cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-
-        expect(results["sv_idle"]).to eq("1")
-      end
-    end
-
-    context "bad database name" do
-      it "does not change any stats" do
-        bad_db_url = URI(pgcat_conn_str)
-        bad_db_url.path = "/wrong_db"
-        expect { PG::connect("#{bad_db_url.to_s}?application_name=bad_db") }.to raise_error(PG::ConnectionBad)
-
-        sleep(1)
-        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_idle cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-
-        expect(results["sv_idle"]).to eq("1")
-      end
-    end
-
-    context "client connects but issues no queries" do
-      it "only affects cl_idle stats" do
-        connections = Array.new(20) { PG::connect(pgcat_conn_str) }
-        sleep(1)
-        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-        expect(results["cl_idle"]).to eq("20")
-        expect(results["sv_idle"]).to eq("1")
-
-        connections.map(&:close)
-        sleep(1.1)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_active cl_idle cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-        expect(results["sv_idle"]).to eq("1")
-      end
-    end
-
-    context "clients connect and make one query" do
-      it "only affects cl_idle, sv_idle stats" do
-        connections = Array.new(5) { PG::connect("#{pgcat_conn_str}?application_name=one_query") }
-        connections.each do |c|
-          Thread.new { c.async_exec("SELECT pg_sleep(2.5)") }
-        end
-
-        sleep(1.1)
-        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_idle cl_waiting cl_cancel_req sv_idle sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-        expect(results["cl_active"]).to eq("5")
-        expect(results["sv_active"]).to eq("5")
-
-        sleep(3)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-        expect(results["cl_idle"]).to eq("5")
-        expect(results["sv_idle"]).to eq("5")
-
-        connections.map(&:close)
-        sleep(1)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_idle cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-        expect(results["sv_idle"]).to eq("5")
-      end
-    end
-
-    context "client connects and opens a transaction and closes connection uncleanly" do
-      it "produces correct statistics" do
-        connections = Array.new(5) { PG::connect("#{pgcat_conn_str}?application_name=one_query") }
-        connections.each do |c|
-          Thread.new do
-            c.async_exec("BEGIN")
-            c.async_exec("SELECT pg_sleep(0.01)")
-            c.close
-          end
-        end
-
-        sleep(1.1)
-        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_idle cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-        expect(results["sv_idle"]).to eq("5")
-      end
-    end
-
-    context "client fail to checkout connection from the pool" do
-      it "counts clients as idle" do
-        new_configs = processes.pgcat.current_config
-        new_configs["general"]["connect_timeout"] = 500
-        new_configs["general"]["ban_time"] = 1
-        new_configs["general"]["shutdown_timeout"] = 1
-        new_configs["pools"]["sharded_db"]["users"]["0"]["pool_size"] = 1
-        processes.pgcat.update_config(new_configs)
-        processes.pgcat.reload_config
-
-        threads = []
-        connections = Array.new(5) { PG::connect("#{pgcat_conn_str}?application_name=one_query") }
-        connections.each do |c|
-          threads << Thread.new { c.async_exec("SELECT pg_sleep(1)") rescue PG::SystemError }
-        end
-
-        sleep(2)
-        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-        expect(results["cl_idle"]).to eq("5")
-        expect(results["sv_idle"]).to eq("1")
-
-        threads.map(&:join)
-        connections.map(&:close)
-      end
-    end
-
-    context "clients overwhelm server pools" do
-      let(:processes) { Helpers::Pgcat.single_instance_setup("sharded_db", 2) }
-
-      it "cl_waiting is updated to show it" do
-        threads = []
-        connections = Array.new(4) { PG::connect("#{pgcat_conn_str}?application_name=one_query") }
-        connections.each do |c|
-          threads << Thread.new { c.async_exec("SELECT pg_sleep(1.5)") }
-        end
-
-        sleep(1.1) # Allow time for stats to update
-        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_idle cl_cancel_req sv_idle sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-
-        expect(results["cl_waiting"]).to eq("2")
-        expect(results["cl_active"]).to eq("2")
-        expect(results["sv_active"]).to eq("2")
-
-        sleep(2.5) # Allow time for stats to update
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        %w[cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
-          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
-        end
-        expect(results["cl_idle"]).to eq("4")
-        expect(results["sv_idle"]).to eq("2")
-
-        threads.map(&:join)
-        connections.map(&:close)
-      end
-
-      it "show correct max_wait" do
-        threads = []
-        connections = Array.new(4) { PG::connect("#{pgcat_conn_str}?application_name=one_query") }
-        connections.each do |c|
-          threads << Thread.new { c.async_exec("SELECT pg_sleep(1.5)") }
-        end
-
-        sleep(2.5) # Allow time for stats to update
-        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-
-        expect(results["maxwait"]).to eq("1")
-        expect(results["maxwait_us"].to_i).to be_within(100_000).of(500_000)
-
-        sleep(4.5) # Allow time for stats to update
-        results = admin_conn.async_exec("SHOW POOLS")[0]
-        expect(results["maxwait"]).to eq("0")
-
-        threads.map(&:join)
-        connections.map(&:close)
-      end
-    end
-  end
-
-  describe "SHOW CLIENTS" do
-    it "reports correct number and application names" do
-      conn_str = processes.pgcat.connection_string("sharded_db", "sharding_user")
-      connections = Array.new(20) { |i| PG::connect("#{conn_str}?application_name=app#{i % 5}") }
-
-      admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-      sleep(1) # Wait for stats to be updated
-
-      results = admin_conn.async_exec("SHOW CLIENTS")
-      expect(results.count).to eq(21) # count admin clients
-      expect(results.select { |c| c["application_name"] == "app3" ||  c["application_name"] == "app4" }.count).to eq(8)
-      expect(results.select { |c| c["database"] == "pgcat" }.count).to eq(1)
-
-      connections[0..5].map(&:close)
-      sleep(1) # Wait for stats to be updated
-      results = admin_conn.async_exec("SHOW CLIENTS")
-      expect(results.count).to eq(15)
-
-      connections[6..].map(&:close)
-      sleep(1) # Wait for stats to be updated
-      expect(admin_conn.async_exec("SHOW CLIENTS").count).to eq(1)
-      admin_conn.close
-    end
-
-    it "reports correct number of queries and transactions" do
-      conn_str = processes.pgcat.connection_string("sharded_db", "sharding_user")
-
-      connections = Array.new(2) { |i| PG::connect("#{conn_str}?application_name=app#{i}") }
-      connections.each do |c|
-        c.async_exec("SELECT 1")
-        c.async_exec("SELECT 2")
-        c.async_exec("SELECT 3")
-        c.async_exec("BEGIN")
-        c.async_exec("SELECT 4")
-        c.async_exec("SELECT 5")
-        c.async_exec("COMMIT")
-      end
-
-      admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-      sleep(1) # Wait for stats to be updated
-
-      results = admin_conn.async_exec("SHOW CLIENTS")
-      expect(results.count).to eq(3)
-      normal_client_results = results.reject { |r| r["database"] == "pgcat" }
-      expect(normal_client_results[0]["transaction_count"]).to eq("4")
-      expect(normal_client_results[1]["transaction_count"]).to eq("4")
-      expect(normal_client_results[0]["query_count"]).to eq("7")
-      expect(normal_client_results[1]["query_count"]).to eq("7")
-
-      admin_conn.close
-      connections.map(&:close)
-    end
-  end
-end
--- a/tests/ruby/helpers/pg_instance.rb
+++ b/tests/ruby/helpers/pg_instance.rb
@@ -1,82 +0,0 @@
-require 'pg'
-require 'toxiproxy'
-
-class PgInstance
-  attr_reader :port
-  attr_reader :username
-  attr_reader :password
-  attr_reader :database_name
-
-  def initialize(port, username, password, database_name)
-    @original_port = port
-    @toxiproxy_port = 10000 + port.to_i
-    @port = @toxiproxy_port
-
-    @username = username
-    @password = password
-    @database_name = database_name
-    @toxiproxy_name = "database_#{@original_port}"
-    Toxiproxy.populate([{
-      name: @toxiproxy_name,
-      listen: "0.0.0.0:#{@toxiproxy_port}",
-      upstream: "localhost:#{@original_port}",
-    }])
-
-    # Toxiproxy server will outlive our PgInstance objects
-    # so we want to destroy our proxies before exiting
-    # Ruby finalizer is ideal for doing this
-    ObjectSpace.define_finalizer(@toxiproxy_name, proc { Toxiproxy[@toxiproxy_name].destroy })
-  end
-
-  def with_connection
-    conn = PG.connect("postgres://#{@username}:#{@password}@localhost:#{port}/#{database_name}")
-    yield conn
-  ensure
-    conn&.close
-  end
-
-  def reset
-    reset_toxics
-    reset_stats
-  end
-
-  def toxiproxy
-    Toxiproxy[@toxiproxy_name]
-  end
-
-  def take_down
-    if block_given?
-      Toxiproxy[@toxiproxy_name].toxic(:limit_data, bytes: 5).apply { yield }
-    else
-      Toxiproxy[@toxiproxy_name].toxic(:limit_data, bytes: 5).toxics.each(&:save)
-    end
-  end
-
-  def add_latency(latency)
-    if block_given?
-      Toxiproxy[@toxiproxy_name].toxic(:latency, latency: latency).apply { yield }
-    else
-      Toxiproxy[@toxiproxy_name].toxic(:latency, latency: latency).toxics.each(&:save)
-    end
-  end
-
-  def delete_proxy
-    Toxiproxy[@toxiproxy_name].delete
-  end
-
-  def reset_toxics
-    Toxiproxy[@toxiproxy_name].toxics.each(&:destroy)
-  end
-
-  def reset_stats
-    with_connection { |c| c.async_exec("SELECT pg_stat_statements_reset()") }
-  end
-
-  def count_query(query)
-    with_connection { |c| c.async_exec("SELECT SUM(calls) FROM pg_stat_statements WHERE query = '#{query}'")[0]["sum"].to_i }
-  end
-
-  def count_select_1_plus_2
-    with_connection { |c| c.async_exec("SELECT SUM(calls) FROM pg_stat_statements WHERE query = 'SELECT $1 + $2'")[0]["sum"].to_i }
-  end
-end
--- a/tests/ruby/helpers/pgcat_helper.rb
+++ b/tests/ruby/helpers/pgcat_helper.rb
@@ -1,144 +0,0 @@
-require 'json'
-require 'ostruct'
-require_relative 'pgcat_process'
-require_relative 'pg_instance'
-
-module Helpers
-  module Pgcat
-    def self.three_shard_setup(pool_name, pool_size, pool_mode="transaction")
-      user = {
-        "password" => "sharding_user",
-        "pool_size" => pool_size,
-        "statement_timeout" => 0,
-        "username" => "sharding_user"
-      }
-
-      pgcat    = PgcatProcess.new("info")
-      primary0 = PgInstance.new(5432, user["username"], user["password"], "shard0")
-      primary1 = PgInstance.new(7432, user["username"], user["password"], "shard1")
-      primary2 = PgInstance.new(8432, user["username"], user["password"], "shard2")
-
-      pgcat_cfg = pgcat.current_config
-      pgcat_cfg["pools"] = {
-        "#{pool_name}" => {
-          "default_role" => "any",
-          "pool_mode" => pool_mode,
-          "primary_reads_enabled" => false,
-          "query_parser_enabled" => false,
-          "sharding_function" => "pg_bigint_hash",
-          "shards" => {
-            "0" => { "database" => "shard0", "servers" => [["localhost", primary0.port.to_s, "primary"]] },
-            "1" => { "database" => "shard1", "servers" => [["localhost", primary1.port.to_s, "primary"]] },
-            "2" => { "database" => "shard2", "servers" => [["localhost", primary2.port.to_s, "primary"]] },
-          },
-          "users" => { "0" => user }
-        }
-      }
-      pgcat.update_config(pgcat_cfg)
-
-      pgcat.start
-      pgcat.wait_until_ready
-
-      OpenStruct.new.tap do |struct|
-        struct.pgcat = pgcat
-        struct.shards = [primary0, primary1, primary2]
-        struct.all_databases = [primary0, primary1, primary2]
-      end
-    end
-
-    def self.single_instance_setup(pool_name, pool_size, pool_mode="transaction")
-      user = {
-        "password" => "sharding_user",
-        "pool_size" => pool_size,
-        "statement_timeout" => 0,
-        "username" => "sharding_user"
-      }
-
-      pgcat = PgcatProcess.new("trace")
-      pgcat_cfg = pgcat.current_config
-
-      primary  = PgInstance.new(5432, user["username"], user["password"], "shard0")
-
-      # Main proxy configs
-      pgcat_cfg["pools"] = {
-        "#{pool_name}" => {
-          "default_role" => "primary",
-          "pool_mode" => pool_mode,
-          "primary_reads_enabled" => false,
-          "query_parser_enabled" => false,
-          "sharding_function" => "pg_bigint_hash",
-          "shards" => {
-            "0" => {
-              "database" => "shard0",
-              "servers" => [
-                ["localhost", primary.port.to_s, "primary"]
-              ]
-            },
-          },
-          "users" => { "0" => user }
-        }
-      }
-      pgcat_cfg["general"]["port"] = pgcat.port
-      pgcat.update_config(pgcat_cfg)
-      pgcat.start
-      pgcat.wait_until_ready
-
-      OpenStruct.new.tap do |struct|
-        struct.pgcat = pgcat
-        struct.primary = primary
-        struct.all_databases = [primary]
-      end
-    end
-
-    def self.single_shard_setup(pool_name, pool_size, pool_mode="transaction")
-      user = {
-        "password" => "sharding_user",
-        "pool_size" => pool_size,
-        "statement_timeout" => 0,
-        "username" => "sharding_user"
-      }
-
-      pgcat = PgcatProcess.new("info")
-      pgcat_cfg = pgcat.current_config
-
-      primary  = PgInstance.new(5432, user["username"], user["password"], "shard0")
-      replica0 = PgInstance.new(7432, user["username"], user["password"], "shard0")
-      replica1 = PgInstance.new(8432, user["username"], user["password"], "shard0")
-      replica2 = PgInstance.new(9432, user["username"], user["password"], "shard0")
-
-      # Main proxy configs
-      pgcat_cfg["pools"] = {
-        "#{pool_name}" => {
-          "default_role" => "any",
-          "pool_mode" => pool_mode,
-          "primary_reads_enabled" => false,
-          "query_parser_enabled" => false,
-          "sharding_function" => "pg_bigint_hash",
-          "shards" => {
-            "0" => {
-              "database" => "shard0",
-              "servers" => [
-                ["localhost", primary.port.to_s, "primary"],
-                ["localhost", replica0.port.to_s, "replica"],
-                ["localhost", replica1.port.to_s, "replica"],
-                ["localhost", replica2.port.to_s, "replica"]
-              ]
-            },
-          },
-          "users" => { "0" => user }
-        }
-      }
-      pgcat_cfg["general"]["port"] = pgcat.port
-      pgcat.update_config(pgcat_cfg)
-      pgcat.start
-      pgcat.wait_until_ready
-
-      OpenStruct.new.tap do |struct|
-        struct.pgcat = pgcat
-        struct.primary = primary
-        struct.replicas = [replica0, replica1, replica2]
-        struct.all_databases = [primary, replica0, replica1, replica2]
-      end
-    end
-  end
-end
--- a/tests/ruby/helpers/pgcat_process.rb
+++ b/tests/ruby/helpers/pgcat_process.rb
@@ -1,116 +0,0 @@
-require 'pg'
-require 'toml'
-require 'fileutils'
-require 'securerandom'
-
-class PgcatProcess
-  attr_reader :port
-  attr_reader :pid
-
-  def self.finalize(pid, log_filename, config_filename)
-    `kill #{pid}`
-    File.delete(config_filename) if File.exist?(config_filename)
-    File.delete(log_filename) if File.exist?(log_filename)
-  end
-
-  def initialize(log_level)
-    @env = {"RUST_LOG" => log_level}
-    @port = rand(20000..32760)
-    @log_level = log_level
-    @log_filename = "/tmp/pgcat_log_#{SecureRandom.urlsafe_base64}.log"
-    @config_filename = "/tmp/pgcat_cfg_#{SecureRandom.urlsafe_base64}.toml"
-
-    @command = "../../target/debug/pgcat #{@config_filename}"
-
-    FileUtils.cp("../../pgcat.toml", @config_filename)
-    cfg = current_config
-    cfg["general"]["port"] = @port.to_i
-    cfg["general"]["enable_prometheus_exporter"] = false
-
-    update_config(cfg)
-  end
-
-  def logs
-    File.read(@log_filename)
-  end
-
-  def update_config(config_hash)
-    @original_config = current_config
-    output_to_write = TOML::Generator.new(config_hash).body
-    output_to_write = output_to_write.gsub(/,\s*["|'](\d+)["|']\s*,/, ',\1,')
-    File.write(@config_filename, output_to_write)
-  end
-
-  def current_config
-    old_cfg = File.read(@config_filename)
-    loadable_string = old_cfg.gsub(/,\s*(\d+)\s*,/, ', "\1",')
-    TOML.load(loadable_string)
-  end
-
-  def reload_config
-    `kill -s HUP #{@pid}`
-    sleep 0.1
-  end
-
-  def start
-    raise StandardError, "Process is already started" unless @pid.nil?
-    @pid = Process.spawn(@env, @command, err: @log_filename, out: @log_filename)
-    ObjectSpace.define_finalizer(@log_filename, proc { PgcatProcess.finalize(@pid, @log_filename, @config_filename) })
-
-    return self
-  end
-
-  def wait_until_ready
-    exc = nil
-    10.times do
-      PG::connect(example_connection_string).close
-
-      return self
-    rescue => e
-      exc = e
-      sleep(0.5)
-    end
-    puts exc
-    raise StandardError, "Process #{@pid} never became ready. Logs #{logs}"
-  end
-
-  def stop
-    `kill #{@pid}`
-    sleep 0.1
-  end
-
-  def shutdown
-    stop
-    File.delete(@config_filename) if File.exist?(@config_filename)
-    File.delete(@log_filename) if File.exist?(@log_filename)
-  end
-
-  def admin_connection_string
-    cfg = current_config
-    username = cfg["general"]["admin_username"]
-    password = cfg["general"]["admin_password"]
-
-    "postgresql://#{username}:#{password}@0.0.0.0:#{@port}/pgcat"
-  end
-
-  def connection_string(pool_name, username)
-    cfg = current_config
-
-    user_idx, user_obj = cfg["pools"][pool_name]["users"].detect { |k, user| user["username"] == username }
-    password = user_obj["password"]
-
-    "postgresql://#{username}:#{password}@0.0.0.0:#{@port}/#{pool_name}"
-  end
-
-  def example_connection_string
-    cfg = current_config
-    first_pool_name = cfg["pools"].keys[0]
-
-    db_name = first_pool_name
-
-    username = cfg["pools"][first_pool_name]["users"]["0"]["username"]
-    password = cfg["pools"][first_pool_name]["users"]["0"]["password"]
-
-    "postgresql://#{username}:#{password}@0.0.0.0:#{@port}/#{db_name}?application_name=example_app"
-  end
-end
--- a/tests/ruby/load_balancing_spec.rb
+++ b/tests/ruby/load_balancing_spec.rb
@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require_relative 'spec_helper'
-
-describe "Load Balancing" do
-  let(:processes) { Helpers::Pgcat.single_shard_setup("sharded_db", 5) }
-  after do
-    processes.all_databases.map(&:reset)
-    processes.pgcat.shutdown
-  end
-
-  context "under regular circumstances" do
-    it "balances query volume between all instances" do
-      conn = PG.connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-
-      query_count = QUERY_COUNT
-      expected_share = query_count / processes.all_databases.count
-      failed_count = 0
-
-      query_count.times do
-        conn.async_exec("SELECT 1 + 2")
-      rescue
-        failed_count += 1
-      end
-
-      expect(failed_count).to eq(0)
-      processes.all_databases.map(&:count_select_1_plus_2).each do |instance_share|
-        expect(instance_share).to be_within(expected_share * MARGIN_OF_ERROR).of(expected_share)
-      end
-    end
-  end
-
-  context "when some replicas are down" do
-    it "balances query volume between working instances" do
-      conn = PG.connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-      expected_share = QUERY_COUNT / (processes.all_databases.count - 2)
-      failed_count = 0
-
-      processes[:replicas][0].take_down do
-        processes[:replicas][1].take_down do
-          QUERY_COUNT.times do
-            conn.async_exec("SELECT 1 + 2")
-          rescue
-            conn = PG.connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-            failed_count += 1
-          end
-        end
-      end
-
-      expect(failed_count).to eq(2)
-      processes.all_databases.each do |instance|
-        queries_routed = instance.count_select_1_plus_2
-        if processes.replicas[0..1].include?(instance)
-          expect(queries_routed).to eq(0)
-        else
-          expect(queries_routed).to be_within(expected_share * MARGIN_OF_ERROR).of(expected_share)
-        end
-      end
-    end
-  end
-end
-
--- a/tests/ruby/misc_spec.rb
+++ b/tests/ruby/misc_spec.rb
@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-require_relative 'spec_helper'
-
-describe "Miscellaneous" do
-  let(:processes) { Helpers::Pgcat.single_shard_setup("sharded_db", 5) }
-  after do
-    processes.all_databases.map(&:reset)
-    processes.pgcat.shutdown
-  end
-
-  describe "Extended Protocol handling" do
-    it "does not send packets that client does not expect during extended protocol sequence" do
-      new_configs = processes.pgcat.current_config
-
-      new_configs["general"]["connect_timeout"] = 500
-      new_configs["general"]["ban_time"] = 1
-      new_configs["general"]["shutdown_timeout"] = 1
-      new_configs["pools"]["sharded_db"]["users"]["0"]["pool_size"] = 1
-
-      processes.pgcat.update_config(new_configs)
-      processes.pgcat.reload_config
-
-      25.times do
-        Thread.new do
-          conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-          conn.async_exec("SELECT pg_sleep(5)") rescue PG::SystemError
-        ensure
-          conn&.close
-        end
-      end
-
-      sleep(0.5)
-      conn_under_test = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-      stdout, stderr = with_captured_stdout_stderr do
-        15.times do |i|
-          conn_under_test.async_exec("SELECT 1") rescue PG::SystemError
-          conn_under_test.exec_params("SELECT #{i} + $1", [i]) rescue PG::SystemError
-          sleep 1
-        end
-      end
-
-      raise StandardError, "Libpq got unexpected messages while idle" if stderr.include?("arrived from server while idle")
-    end
-  end
-
-  describe "Pool recycling after config reload" do
-    let(:processes) { Helpers::Pgcat.three_shard_setup("sharded_db", 5) }
-
-    it "should update pools for new clients and clients that are no longer in transaction" do
-      server_conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-      server_conn.async_exec("BEGIN")
-
-      # No config change yet, client should set old configs
-      current_datebase_from_pg = server_conn.async_exec("SELECT current_database();")[0]["current_database"]
-      expect(current_datebase_from_pg).to eq('shard0')
-
-      # Swap shards
-      new_config = processes.pgcat.current_config
-      shard0 = new_config["pools"]["sharded_db"]["shards"]["0"]
-      shard1 = new_config["pools"]["sharded_db"]["shards"]["1"]
-      new_config["pools"]["sharded_db"]["shards"]["0"] = shard1
-      new_config["pools"]["sharded_db"]["shards"]["1"] = shard0
-
-      # Reload config
-      processes.pgcat.update_config(new_config)
-      processes.pgcat.reload_config
-      sleep 0.5
-
-      # Config changed but transaction is in progress, client should set old configs
-      current_datebase_from_pg = server_conn.async_exec("SELECT current_database();")[0]["current_database"]
-      expect(current_datebase_from_pg).to eq('shard0')
-      server_conn.async_exec("COMMIT")
-
-      # Transaction finished, client should get new configs
-      current_datebase_from_pg = server_conn.async_exec("SELECT current_database();")[0]["current_database"]
-      expect(current_datebase_from_pg).to eq('shard1')
-
-      # New connection should get new configs
-      server_conn.close()
-      server_conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-      current_datebase_from_pg = server_conn.async_exec("SELECT current_database();")[0]["current_database"]
-      expect(current_datebase_from_pg).to eq('shard1')
-    end
-  end
-
-  describe "Clients closing connection in the middle of transaction" do
-    it "sends a rollback to the server" do
-      conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-      conn.async_exec("SET SERVER ROLE to 'primary'")
-      conn.async_exec("BEGIN")
-      conn.close
-
-      expect(processes.primary.count_query("ROLLBACK")).to eq(1)
-    end
-  end
-
-  describe "Server version reporting" do
-    it "reports correct version for normal and admin databases" do
-      server_conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-      expect(server_conn.server_version).not_to eq(0)
-      server_conn.close
-
-      admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-      expect(admin_conn.server_version).not_to eq(0)
-      admin_conn.close
-    end
-  end
-
-  describe "State clearance" do
-    context "session mode" do
-      let(:processes) { Helpers::Pgcat.single_shard_setup("sharded_db", 5, "session") }
-
-      it "Clears state before connection checkin" do
-        # Both modes of operation should not raise
-        # ERROR:  prepared statement "prepared_q" already exists
-        15.times do
-          conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-          conn.async_exec("PREPARE prepared_q (int) AS SELECT $1")
-          conn.close
-        end
-
-        conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-        initial_value = conn.async_exec("SHOW statement_timeout")[0]["statement_timeout"]
-        conn.async_exec("SET statement_timeout to 1000")
-        current_value = conn.async_exec("SHOW statement_timeout")[0]["statement_timeout"]
-        expect(conn.async_exec("SHOW statement_timeout")[0]["statement_timeout"]).to eq("1s")
-        conn.close
-      end
-
-      it "Does not send DISCARD ALL unless necessary" do
-        10.times do
-          conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-          conn.async_exec("SET SERVER ROLE to 'primary'")
-          conn.async_exec("SELECT 1")
-          conn.close
-        end
-
-        expect(processes.primary.count_query("DISCARD ALL")).to eq(0)
-
-        10.times do
-          conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-          conn.async_exec("SET SERVER ROLE to 'primary'")
-          conn.async_exec("SELECT 1")
-          conn.async_exec("SET statement_timeout to 5000")
-          conn.close
-        end
-
-        expect(processes.primary.count_query("DISCARD ALL")).to eq(10)
-      end
-    end
-
-    context "transaction mode" do
-      let(:processes) { Helpers::Pgcat.single_shard_setup("sharded_db", 5, "transaction") }
-      it "Clears state before connection checkin" do
-        # Both modes of operation should not raise
-        # ERROR:  prepared statement "prepared_q" already exists
-        15.times do
-          conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-          conn.async_exec("PREPARE prepared_q (int) AS SELECT $1")
-          conn.close
-        end
-
-        15.times do
-          conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-          conn.prepare("prepared_q", "SELECT $1")
-          conn.close
-        end
-      end
-
-      it "Does not send DISCARD ALL unless necessary" do
-        10.times do
-          conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-          conn.async_exec("SET SERVER ROLE to 'primary'")
-          conn.async_exec("SELECT 1")
-          conn.exec_params("SELECT $1", [1])
-          conn.close
-        end
-
-        expect(processes.primary.count_query("DISCARD ALL")).to eq(0)
-
-        10.times do
-          conn = PG::connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-          conn.async_exec("SET SERVER ROLE to 'primary'")
-          conn.async_exec("SELECT 1")
-          conn.async_exec("SET statement_timeout to 5000")
-          conn.close
-        end
-
-        expect(processes.primary.count_query("DISCARD ALL")).to eq(10)
-      end
-    end
-  end
-end
--- a/tests/ruby/routing_spec.rb
+++ b/tests/ruby/routing_spec.rb
@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-require_relative 'spec_helper'
-
-
-describe "Routing" do
-  let(:processes) { Helpers::Pgcat.single_shard_setup("sharded_db", 5) }
-  after do
-    processes.all_databases.map(&:reset)
-    processes.pgcat.shutdown
-  end
-
-  describe "SET ROLE" do
-    context "primary" do
-      it "routes queries only to primary" do
-        conn = PG.connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-        conn.async_exec("SET SERVER ROLE to 'primary'")
-
-        query_count = 30
-        failed_count = 0
-
-        query_count.times do
-          conn.async_exec("SELECT 1 + 2")
-        rescue
-          failed_count += 1
-        end
-
-        expect(failed_count).to eq(0)
-        processes.replicas.map(&:count_select_1_plus_2).each do |instance_share|
-          expect(instance_share).to eq(0)
-        end
-
-        expect(processes.primary.count_select_1_plus_2).to eq(query_count)
-      end
-    end
-    context "replica" do
-      it "routes queries only to replicas" do
-        conn = PG.connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-        conn.async_exec("SET SERVER ROLE to 'replica'")
-
-        expected_share = QUERY_COUNT / processes.replicas.count
-        failed_count = 0
-
-        QUERY_COUNT.times do
-          conn.async_exec("SELECT 1 + 2")
-        rescue
-          failed_count += 1
-        end
-
-        expect(failed_count).to eq(0)
-
-        processes.replicas.map(&:count_select_1_plus_2).each do |instance_share|
-          expect(instance_share).to be_within(expected_share * MARGIN_OF_ERROR).of(expected_share)
-        end
-
-        expect(processes.primary.count_select_1_plus_2).to eq(0)
-      end
-    end
-
-    context "any" do
-      it "routes queries to all instances" do
-        conn = PG.connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-        conn.async_exec("SET SERVER ROLE to 'any'")
-
-        expected_share = QUERY_COUNT / processes.all_databases.count
-        failed_count = 0
-
-        QUERY_COUNT.times do
-          conn.async_exec("SELECT 1 + 2")
-        rescue
-          failed_count += 1
-        end
-
-        expect(failed_count).to eq(0)
-
-        processes.all_databases.map(&:count_select_1_plus_2).each do |instance_share|
-          expect(instance_share).to be_within(expected_share * MARGIN_OF_ERROR).of(expected_share)
-        end
-      end
-    end
-  end
-end
--- a/tests/ruby/spec_helper.rb
+++ b/tests/ruby/spec_helper.rb
@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'pg'
-require_relative 'helpers/pgcat_helper'
-
-QUERY_COUNT = 300
-MARGIN_OF_ERROR = 0.30
-
-def with_captured_stdout_stderr
-  sout = STDOUT.clone
-  serr = STDERR.clone
-  STDOUT.reopen("/tmp/out.txt", "w+")
-  STDERR.reopen("/tmp/err.txt", "w+")
-  STDOUT.sync = true
-  STDERR.sync = true
-  yield
-  return File.read('/tmp/out.txt'), File.read('/tmp/err.txt')
-ensure
-  STDOUT.reopen(sout)
-  STDERR.reopen(serr)
-end
--- a/tests/ruby/tests.rb
+++ b/tests/ruby/tests.rb
@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'pg'
+
 require 'active_record'

 # Uncomment these two to see all queries.
@@ -12,8 +12,7 @@ ActiveRecord::Base.establish_connection(
  port: 6432,
  username: 'sharding_user',
  password: 'sharding_user',
-  database: 'sharded_db',
-  application_name: 'testing_pgcat',
+  database: 'rails_dev',
  prepared_statements: false, # Transaction mode
  advisory_locks: false # Same
 )
--- a/tests/sharding/query_routing_setup.sql
+++ b/tests/sharding/query_routing_setup.sql
@@ -1,12 +1,11 @@
+
 DROP DATABASE IF EXISTS shard0;
 DROP DATABASE IF EXISTS shard1;
 DROP DATABASE IF EXISTS shard2;
-DROP DATABASE IF EXISTS some_db;

 CREATE DATABASE shard0;
 CREATE DATABASE shard1;
 CREATE DATABASE shard2;
-CREATE DATABASE some_db;

 \c shard0

@@ -42,63 +41,21 @@ CREATE TABLE data (

 CREATE TABLE data_shard_2 PARTITION OF data FOR VALUES WITH (MODULUS 3, REMAINDER 2);

-
-\c some_db
-
-DROP TABLE IF EXISTS data CASCADE;
-
-CREATE TABLE data (
-    id BIGINT,
-    value VARCHAR
-);
-
 DROP ROLE IF EXISTS sharding_user;
-DROP ROLE IF EXISTS other_user;
-DROP ROLE IF EXISTS simple_user;
 CREATE ROLE sharding_user ENCRYPTED PASSWORD 'sharding_user' LOGIN;
-CREATE ROLE other_user ENCRYPTED PASSWORD 'other_user' LOGIN;
-CREATE ROLE simple_user ENCRYPTED PASSWORD 'simple_user' LOGIN;

-GRANT CONNECT ON DATABASE shard0  TO sharding_user;
-GRANT CONNECT ON DATABASE shard1  TO sharding_user;
-GRANT CONNECT ON DATABASE shard2  TO sharding_user;
-
-GRANT CONNECT ON DATABASE shard0  TO other_user;
-GRANT CONNECT ON DATABASE shard1  TO other_user;
-GRANT CONNECT ON DATABASE shard2  TO other_user;
-
-GRANT CONNECT ON DATABASE some_db TO simple_user;
+GRANT CONNECT ON DATABASE shard0 TO sharding_user;
+GRANT CONNECT ON DATABASE shard1 TO sharding_user;
+GRANT CONNECT ON DATABASE shard2 TO sharding_user;

 \c shard0
-CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
-GRANT EXECUTE ON FUNCTION pg_stat_statements_reset TO sharding_user;
 GRANT ALL ON SCHEMA public TO sharding_user;
 GRANT ALL ON TABLE data TO sharding_user;
-GRANT ALL ON SCHEMA public TO other_user;
-GRANT ALL ON TABLE data TO other_user;
-GRANT EXECUTE ON FUNCTION pg_stat_statements_reset TO other_user;

 \c shard1
-CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
-GRANT EXECUTE ON FUNCTION pg_stat_statements_reset TO sharding_user;
 GRANT ALL ON SCHEMA public TO sharding_user;
 GRANT ALL ON TABLE data TO sharding_user;
-GRANT ALL ON SCHEMA public TO other_user;
-GRANT ALL ON TABLE data TO other_user;
-GRANT EXECUTE ON FUNCTION pg_stat_statements_reset TO other_user;
-

 \c shard2
-CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
-GRANT EXECUTE ON FUNCTION pg_stat_statements_reset TO sharding_user;
 GRANT ALL ON SCHEMA public TO sharding_user;
 GRANT ALL ON TABLE data TO sharding_user;
-GRANT ALL ON SCHEMA public TO other_user;
-GRANT ALL ON TABLE data TO other_user;
-GRANT EXECUTE ON FUNCTION pg_stat_statements_reset TO other_user;
-
-\c some_db
-CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
-GRANT EXECUTE ON FUNCTION pg_stat_statements_reset TO simple_user;
-GRANT ALL ON SCHEMA public TO simple_user;
-GRANT ALL ON TABLE data TO simple_user;
--- a/tests/sharding/query_routing_test_primary_replica.sql
+++ b/tests/sharding/query_routing_test_primary_replica.sql
@@ -151,12 +151,3 @@ SELECT 1;
 set server role to 'replica';
 SeT SeRver Role TO 'PrImARY';
 select 1;
-
-SET PRIMARY READS TO 'on';
-SELECT 1;
-
-SET PRIMARY READS TO 'off';
-SELECT 1;
-
-SET PRIMARY READS TO 'default';
-SELECT 1;
Author	SHA1	Message	Date
Lev Kokotov	d4d83a6fe7	fix borrowing errors	2022-03-04 12:24:53 -08:00
Sven Elfgren	5f745859c0	Started on md5 auth. Left to figure out: Whats the right format to store user:pw in userlist? hashmap errors? actually do hash:x comparison	2022-03-04 12:11:17 -07:00