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 01:16:30 +00:00 · 2022-03-04 12:11:17 -07:00
45 changed files with 6544 additions and 57 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -0,0 +1,55 @@
+# Use the latest 2.1 version of CircleCI pipeline process engine.
+# See: https://circleci.com/docs/2.0/configuration-reference
+version: 2.1
+
+# Define a job to be invoked later in a workflow.
+# See: https://circleci.com/docs/2.0/configuration-reference/#jobs
+jobs:
+  build:
+    # 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: cimg/rust:1.58.1
+        environment:
+          RUST_LOG: info
+      - image: cimg/postgres:14.0
+        auth:
+          username: mydockerhub-user
+          password: $DOCKERHUB_PASSWORD
+        environment:
+          POSTGRES_USER: postgres
+          POSTGRES_DB: postgres
+    # Add steps to the job
+    # See: https://circleci.com/docs/2.0/configuration-reference/#steps
+    steps:
+      - checkout
+      - restore_cache:
+          key: cargo-lock-2-{{ checksum "Cargo.lock" }}
+      - run:
+          name: "Lint"
+          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"
+      - run:
+          name: "Build" 
+          command: "cargo build"
+      - run:
+          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:
+            - target
+            - ~/.cargo
+
+
+# Invoke jobs via workflows
+# See: https://circleci.com/docs/2.0/configuration-reference/#workflows
+workflows:
+  build:
+    jobs:
+      - build
--- a/.circleci/pgcat.toml
+++ b/.circleci/pgcat.toml
@@ -0,0 +1,108 @@
+#
+# 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
+
+# How many connections to allocate per server.
+pool_size = 15
+
+# 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.
+#
+# 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 = 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 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"
--- a/.circleci/run_tests.sh
+++ b/.circleci/run_tests.sh
@@ -0,0 +1,103 @@
+#!/bin/bash
+
+set -e
+set -o xtrace
+
+# Start PgCat with a particular log level
+# for inspection.
+function start_pgcat() {
+    kill -s SIGINT $(pgrep pgcat) || true
+    RUST_LOG=${1} ./target/debug/pgcat .circleci/pgcat.toml &
+    sleep 1
+}
+
+# Setup the database with shards and user
+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.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
+toxiproxy-server &
+sleep 1
+
+# Create a database at port 5433, forward it to Postgres
+toxiproxy-cli create -l 127.0.0.1:5433 -u 127.0.0.1:5432 postgres_replica
+
+start_pgcat "info"
+
+# pgbench test
+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 -h 127.0.0.1 -p 6432 -c 'COPY (SELECT * FROM pgbench_accounts LIMIT 15) TO STDOUT;' > /dev/null
+
+# Query cancellation test
+(psql -h 127.0.0.1 -p 6432 -c 'SELECT pg_sleep(5)' || true) &
+killall psql -s SIGINT
+
+# Sharding insert
+psql -e -h 127.0.0.1 -p 6432 -f tests/sharding/query_routing_test_insert.sql
+
+# Sharding select
+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 -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 && \
+    ruby tests.rb && \
+cd ../..
+
+# Admin tests
+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 "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 -e -h 127.0.0.1 -p 6432 <<-EOF
+SELECT 1;
+SELECT 1;
+SELECT 1;
+EOF
+
+# Remove latency
+toxiproxy-cli toxic remove --toxicName latency_downstream postgres_replica
+
+start_pgcat "info"
+
+# Test session mode (and config reload)
+sed -i 's/pool_mode = "transaction"/pool_mode = "session"/' pgcat.toml
+
+# Reload config test
+kill -SIGHUP $(pgrep pgcat)
+
+# Prepared statements that will only work in session mode
+pgbench -h 127.0.0.1 -p 6432 -t 500 -c 2 --protocol prepared
+
+# Attempt clean shut down
+killall pgcat -s SIGINT
+
+# Allow for graceful shutdown
+sleep 1
--- a/.dockerignore
+++ b/.dockerignore
@@ -0,0 +1,4 @@
+target/
+tests/
+tracing/
+.circleci/
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
--- a/.gitignore
+++ b/.gitignore
@@ -1,15 +1,5 @@
-.idea
 /target
 *.deb
-.vscode
-*.profraw
-cov/
-lcov.info
-
-# Dev
-dev/.bash_history
-dev/cache
-!dev/cache/.keepme
-.venv
-**/__pycache__
-.bundle
+.idea/*
+tests/ruby/.bundle/*
+tests/ruby/vendor/*
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -0,0 +1,19 @@
+## Introduction
+
+Thank you for contributing! Just a few tips here:
+
+1. `cargo fmt` your code before opening up a PR
+2. Run the test suite (e.g. `pgbench`) to make sure everything still works. The tests are in `.circleci/run_tests.sh`.
+3. Performance is important, make sure there are no regressions in your branch vs. `main`.
+
+Happy hacking!
+
+## TODOs
+
+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
@@ -0,0 +1,701 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "arc-swap"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5d78ce20460b82d3fa150275ed9d55e21064fc7951177baacf86a145c4a4b1f"
+
+[[package]]
+name = "async-trait"
+version = "0.1.52"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "061a7acccaa286c011ddc30970520b98fa40e00c9d644633fb26b5fc63a265e3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "bb8"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e9f4fa9768efd269499d8fba693260cfc670891cf6de3adc935588447a77cc8"
+dependencies = [
+ "async-trait",
+ "futures-channel",
+ "futures-util",
+ "parking_lot",
+ "tokio",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1d36a02058e76b040de25a4464ba1c80935655595b661505c8b39b664828b95"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bytes"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "chrono"
+version = "0.4.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
+dependencies = [
+ "libc",
+ "num-integer",
+ "num-traits",
+ "time",
+ "winapi",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d6b536309245c849479fba3da410962a43ed8e51c26b729208ec0ac2798d0"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b697d66081d42af4fba142d56918a3cb21dc8eb63372c6b85d14f44fb9c5979b"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "generic-array",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3dda0b6588335f360afc675d0564c17a77a2bda81ca178a4b6081bd86c7f0b"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0c8ff0461b82559810cdccfde3215c3f373807f5e5232b71479bff7bb2583d7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ee7c6485c30167ce4dfb83ac568a849fe53274c831081476ee13e0dce1aad72"
+
+[[package]]
+name = "futures-util"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b5cf40b47a271f77a8b1bec03ca09044d99d2372c0de244e66430761127164"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-task",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd48d33ec7f05fbfa152300fdad764757cbded343c1aa1cff2fbaf4134851803"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "418d37c8b1d42553c93648be529cb70f920d3baf8ef469b74b9638df426e0b4c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+
+[[package]]
+name = "libc"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e74d72e0f9b65b5b4ca49a346af3976df0f9c61d550727f349ecd559f251a26c"
+
+[[package]]
+name = "lock_api"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "md-5"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6a38fc55c8bbc10058782919516f88826e70320db6d206aebc49611d24216ae"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "mio"
+version = "0.7.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8067b404fe97c70829f082dec8bcf4f71225d7eaea1d8645349cb76fa06205cc"
+dependencies = [
+ "libc",
+ "log",
+ "miow",
+ "ntapi",
+ "winapi",
+]
+
+[[package]]
+name = "miow"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "ntapi"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+
+[[package]]
+name = "parking_lot"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+dependencies = [
+ "instant",
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216"
+dependencies = [
+ "cfg-if",
+ "instant",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "winapi",
+]
+
+[[package]]
+name = "pgcat"
+version = "0.1.0"
+dependencies = [
+ "arc-swap",
+ "async-trait",
+ "bb8",
+ "bytes",
+ "chrono",
+ "env_logger",
+ "log",
+ "md-5",
+ "num_cpus",
+ "once_cell",
+ "parking_lot",
+ "rand",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "sha-1",
+ "sqlparser",
+ "statsd",
+ "tokio",
+ "toml",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "ryu"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "serde"
+version = "1.0.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"
+
+[[package]]
+name = "serde_derive"
+version = "1.0.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "028f48d513f9678cda28f6e4064755b3fbb2af6acd672f2c209b62323f7aea0f"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5"
+
+[[package]]
+name = "smallvec"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
+
+[[package]]
+name = "sqlparser"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8f192f29f4aa49e57bebd0aa05858e0a1f32dd270af36efe49edb82cbfffab6"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "statsd"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1efceb4bf2c0b5ebec94354285a43bbbed1375605bdf2ebe4132299434a330"
+dependencies = [
+ "rand",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "time"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
+dependencies = [
+ "libc",
+ "wasi",
+ "winapi",
+]
+
+[[package]]
+name = "tokio"
+version = "1.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c27a64b625de6d309e8c57716ba93021dccf1b3b5c97edd6d3dd2d2135afc0a"
+dependencies = [
+ "bytes",
+ "libc",
+ "memchr",
+ "mio",
+ "num_cpus",
+ "once_cell",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "tokio-macros",
+ "winapi",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b557f72f448c511a979e2564e55d74e6c4432fc96ff4f6241bc6bded342643b7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "toml"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "typenum"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "pgcat"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+tokio = { version = "1", features = ["full"] }
+bytes = "1"
+md-5 = "0.10"
+bb8 = "0.7"
+async-trait = "0.1"
+rand = "0.8"
+chrono = "0.4"
+sha-1 = "0.10"
+toml = "0.5"
+serde = "1"
+serde_derive = "1"
+serde_json = "1"
+regex = "1"
+num_cpus = "1"
+once_cell = "1"
+statsd = "0.15"
+sqlparser = "0.14"
+log = "0.4"
+arc-swap = "1"
+env_logger = "0.9"
+parking_lot = "0.11"
--- a/11
+++ b/11
@@ -0,0 +1,11 @@
+FROM rust:1.58-slim-buster AS builder
+COPY . /app
+WORKDIR /app
+RUN cargo build --release
+
+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
+ENTRYPOINT ["/usr/bin/pgcat"]
--- a/20
+++ b/20
@@ -0,0 +1,20 @@
+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
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/README.md
+++ b/README.md
@@ -1 +1,485 @@
-## PgCat: Nextgen PostgreSQL Pooler Helm Charts
+# PgCat
+
+[![CircleCI](https://circleci.com/gh/levkk/pgcat/tree/main.svg?style=svg)](https://circleci.com/gh/levkk/pgcat/tree/main)
+
+![PgCat](./pgcat3.png)
+
+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 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.
+
+### 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`                           |
+| `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
+
+1. Install Rust (latest stable will work great).
+2. `cargo build --release` (to get better benchmarks).
+3. Change the config in `pgcat.toml` to fit your setup (optional given next step).
+4. Install Postgres and run `psql -f tests/sharding/query_routing_setup.sql` (user/password may be required depending on your setup)
+5. `RUST_LOG=info cargo run --release` You're ready to go!
+
+### Tests
+
+Quickest way to test your changes is to use pgbench:
+
+```
+pgbench -i -h 127.0.0.1 -p 6432 && \
+pgbench -t 1000 -p 6432 -h 127.0.0.1 --protocol simple && \
+pgbench -t 1000 -p 6432 -h 127.0.0.1 --protocol extended
+```
+
+See [sharding README](./tests/sharding/README.md) for sharding logic testing.
+
+| **Feature**           | **Tested in CI**   | **Tested manually** | **Comments**                                                                                                             |
+|-----------------------|--------------------|---------------------|--------------------------------------------------------------------------------------------------------------------------|
+| Transaction pooling   | :white_check_mark: | :white_check_mark:  | Used by default for all tests.                                                                                           |
+| Session pooling       | :white_check_mark: | :white_check_mark:  | Tested by running pgbench with `--protocol prepared` which only works in session mode.                                   |
+| `COPY`                | :white_check_mark: | :white_check_mark:  | `pgbench -i` uses `COPY`. `COPY FROM` is tested as well.                                                                 |
+| Query cancellation    | :white_check_mark: | :white_check_mark:  | `psql -c 'SELECT pg_sleep(1000);'` and press `Ctrl-C`.                                                                   |
+| 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 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
+
+### Session mode
+In session mode, a client talks to one server for the duration of the connection. Prepared statements, `SET`, and advisory locks are supported. In terms of supported features, there is very little if any difference between session mode and talking directly to the server.
+
+To use session mode, change `pool_mode = "session"`.
+
+### Transaction mode
+In transaction mode, a client talks to one server for the duration of a single transaction; once it's over, the server is returned to the pool. Prepared statements, `SET`, and advisory locks are not supported; alternatives are to use `SET LOCAL` and `pg_advisory_xact_lock` which are scoped to the transaction.
+
+This mode is enabled by default.
+
+### Load balancing of read 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.
+
+The query parser is disabled by default.
+
+#### Query parser
+The query parser will do its best to determine where the query should go, but sometimes that's not possible. In that case, the client can select which server it wants using this custom SQL syntax:
+
+```sql
+-- To talk to the primary for the duration of the next transaction:
+SET SERVER ROLE TO 'primary';
+
+-- To talk to the replica for the duration of the next transaction:
+SET SERVER ROLE TO 'replica';
+
+-- Let the query parser decide
+SET SERVER ROLE TO 'auto';
+
+-- Pick any server at random
+SET SERVER ROLE TO 'any';
+
+-- Reset to default configured settings
+SET SERVER ROLE TO 'default';
+```
+
+The setting will persist until it's changed again or the client disconnects.
+
+By default, all queries are routed to the first available server; `default_role` setting controls this behavior.
+
+### Failover
+All servers are checked with a `SELECT 1` query before being given to a client. If the server is not reachable, it will be banned and cannot serve any more transactions for the duration of the ban. The queries are routed to the remaining servers. If all servers become banned, the ban list is cleared: this is a safety precaution against false positives. The primary can never be banned.
+
+The ban time can be changed with `ban_time`. The default is 60 seconds.
+
+Failover behavior can get pretty interesting (read complex) when multiple configurations and factors are involved. The table below will try to explain what PgCat does in each scenario:
+
+| **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 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 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 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.                                                                                                                                  |
+| Write query               | replica                  | false                      | false                       | up               | The query is routed to the replica and fails. The client receives an error.                                                                                          |
+| Write query               | unset (any)              | true                       | false                       | down             | The query is routed to the primary and fails. The client receives an error.                                                                                          |
+| Write query               | unset (any)              | true                       | true                        | down             | The query is routed to the primary and fails. The client receives an error.                                                                                          |
+| Write query               | primary                  | false                      | false                       | down             | The query is routed to the primary and fails. The client receives an error.                                                                                          |
+|                           |                          |                            |                             |                  |                                                                                                                                                                      |
+
+### Sharding
+We use the `PARTITION BY HASH` hashing function, the same as used by Postgres for declarative partitioning. This allows to shard the database using Postgres partitions and place the partitions on different servers (shards). Both read and write queries can be routed to the shards using this pooler.
+
+To route queries to a particular shard, we use this custom SQL syntax:
+
+```sql
+-- To talk to a shard explicitely
+SET SHARD TO '1';
+
+-- To let the pooler choose based on a value
+SET SHARDING KEY TO '1234';
+```
+
+The active shard will last until it's changed again or the client disconnects. By default, the queries are routed to shard 0.
+
+For hash function implementation, see `src/sharding.rs` and `tests/sharding/partition_hash_test_setup.sql`.
+
+#### ActiveRecord/Rails
+
+```ruby
+class User < ActiveRecord::Base
+end
+
+# Metadata will be fetched from shard 0
+ActiveRecord::Base.establish_connection
+
+# Grab a bunch of users from shard 1
+User.connection.execute "SET SHARD TO '1'"
+User.take(10)
+
+# Using id as the sharding key
+User.connection.execute "SET SHARDING KEY TO '1234'"
+User.find_by_id(1234)
+
+# Using geographical sharding
+User.connection.execute "SET SERVER ROLE TO 'primary'"
+User.connection.execute "SET SHARDING KEY TO '85'"
+User.create(name: "test user", email: "test@example.com", zone_id: 85)
+
+# Let the query parser figure out where the query should go.
+# We are still on shard = hash(85) % shards.
+User.connection.execute "SET SERVER ROLE TO 'auto'"
+User.find_by_email("test@example.com")
+```
+
+#### Raw SQL
+
+```sql
+-- Grab a bunch of users from shard 1
+SET SHARD TO '1';
+SELECT * FROM users LIMT 10;
+
+-- Find by id
+SET SHARDING KEY TO '1234';
+SELECT * FROM USERS WHERE id = 1234;
+
+-- Writing in a primary/replicas configuration.
+SET SHARDING ROLE TO 'primary';
+SET SHARDING KEY TO '85';
+INSERT INTO users (name, email, zome_id) VALUES ('test user', 'test@example.com', 85);
+
+SET SERVER ROLE TO 'auto'; -- let the query router figure out where the query should go
+SELECT * FROM users WHERE email = 'test@example.com'; -- shard setting lasts until set again; we are reading from the primary
+```
+
+### Statistics reporting
+
+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. Not all settings are currently supported by live reload:
+
+| **Config**              | **Requires restart** |
+|-------------------------|----------------------|
+| `host`                  | yes                  |
+| `port`                  | yes                  |
+| `pool_mode`             | no                   |
+| `connect_timeout`       | yes                  |
+| `healthcheck_timeout`   | no                   |
+| `ban_time`              | no                   |
+| `statsd_address`        | yes                  |
+| `user`                  | yes                  |
+| `shards`                | yes                  |
+| `default_role`          | no                   |
+| `primary_reads_enabled` | no                   |
+| `query_parser_enabled`  | no                   |
+
+
+## Benchmarks
+
+You can setup PgBench locally through PgCat:
+
+```
+pgbench -h 127.0.0.1 -p 6432 -i
+```
+
+Coincidenly, this uses `COPY` so you can test if that works. Additionally, we'll be running the following PgBench configurations:
+
+1. 16 clients, 2 threads
+2. 32 clients, 2 threads
+3. 64 clients, 2 threads
+4. 128 clients, 2 threads
+
+All queries will be `SELECT` only (`-S`) just so disks don't get in the way, since the dataset will be effectively all in RAM.
+
+My setup:
+
+- 8 cores, 16 hyperthreaded (AMD Ryzen 5800X)
+- 32GB RAM (doesn't matter for this benchmark, except to prove that Postgres will fit the whole dataset into RAM)
+
+### PgBouncer
+
+#### Config
+
+```ini
+[databases]
+shard0 = host=localhost port=5432 user=sharding_user password=sharding_user
+
+[pgbouncer]
+pool_mode = transaction
+max_client_conn = 1000
+```
+
+Everything else stays default.
+
+#### Runs
+
+
+```
+$ pgbench -t 1000 -c 16 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended shard0
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 16
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 16000/16000
+latency average = 0.155 ms
+tps = 103417.377469 (including connections establishing)
+tps = 103510.639935 (excluding connections establishing)
+
+
+$ pgbench -t 1000 -c 32 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended shard0
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 32
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 32000/32000
+latency average = 0.290 ms
+tps = 110325.939785 (including connections establishing)
+tps = 110386.513435 (excluding connections establishing)
+
+
+$ pgbench -t 1000 -c 64 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended shard0
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 64
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 64000/64000
+latency average = 0.692 ms
+tps = 92470.427412 (including connections establishing)
+tps = 92618.389350 (excluding connections establishing)
+
+$ pgbench -t 1000 -c 128 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended shard0
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 128
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 128000/128000
+latency average = 1.406 ms
+tps = 91013.429985 (including connections establishing)
+tps = 91067.583928 (excluding connections establishing)
+```
+
+### PgCat
+
+#### Config
+
+The only thing that matters here is the number of workers in the Tokio pool. Make sure to set it to < than the number of your CPU cores.
+Also account for hyper-threading, so if you have that, take the number you got above and divide it by two, that way only "real" cores serving
+requests.
+
+My setup is 16 threads, 8 cores (`htop` shows as 16 CPUs), so I set the `max_workers` in Tokio to 4. Too many, and it starts conflicting with PgBench
+which is also running on the same system.
+
+#### Runs
+
+
+```
+$ pgbench -t 1000 -c 16 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 16
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 16000/16000
+latency average = 0.164 ms
+tps = 97705.088232 (including connections establishing)
+tps = 97872.216045 (excluding connections establishing)
+
+
+$ pgbench -t 1000 -c 32 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 32
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 32000/32000
+latency average = 0.288 ms
+tps = 111300.488119 (including connections establishing)
+tps = 111413.107800 (excluding connections establishing)
+
+
+$ pgbench -t 1000 -c 64 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 64
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 64000/64000
+latency average = 0.556 ms
+tps = 115190.496139 (including connections establishing)
+tps = 115247.521295 (excluding connections establishing)
+
+$ pgbench -t 1000 -c 128 -j 2 -p 6432 -h 127.0.0.1 -S --protocol extended
+
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 128
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 128000/128000
+latency average = 1.135 ms
+tps = 112770.562239 (including connections establishing)
+tps = 112796.502381 (excluding connections establishing)
+```
+
+### Direct Postgres
+
+Always good to have a base line.
+
+#### Runs
+
+```
+$ pgbench -t 1000 -c 16 -j 2 -p 5432 -h 127.0.0.1 -S --protocol extended shard0
+Password: 
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 16
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 16000/16000
+latency average = 0.115 ms
+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: 
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 32
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 32000/32000
+latency average = 0.212 ms
+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: 
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 64
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 64000/64000
+latency average = 0.420 ms
+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: 
+starting vacuum...end.
+transaction type: <builtin: select only>
+scaling factor: 1
+query mode: extended
+number of clients: 128
+number of threads: 2
+number of transactions per client: 1000
+number of transactions actually processed: 128000/128000
+latency average = 0.854 ms
+tps = 149818.594087 (including connections establishing)
+tps = 150200.603049 (excluding connections establishing)
+```
--- a/index.yaml
+++ b/index.yaml
@@ -1,43 +0,0 @@
-apiVersion: v1
-entries:
-  pgcat:
-  - apiVersion: v2
-    appVersion: 1.2.0
-    created: "2024-11-08T12:07:27.767665231Z"
-    description: A Helm chart for PgCat a PostgreSQL pooler and proxy (like PgBouncer)
-      with support for sharding, load balancing, failover and mirroring.
-    digest: 904a643eef7f1e311770a760578a9523ae648502eba0a040ac3ff3871b1144f7
-    maintainers:
-    - email: support@w6d.io
-      name: Wildcard
-    name: pgcat
-    urls:
-    - https://github.com/postgresml/pgcat/releases/download/pgcat-0.2.4/pgcat-0.2.4.tgz
-    version: 0.2.4
-  - apiVersion: v2
-    appVersion: 1.2.0
-    created: "2024-11-02T23:05:55.57497085Z"
-    description: A Helm chart for PgCat a PostgreSQL pooler and proxy (like PgBouncer)
-      with support for sharding, load balancing, failover and mirroring.
-    digest: b5a0236a9072523d96056a1e8567c2c8e862221b8b6ce8d038fbee3d3505986e
-    maintainers:
-    - email: support@w6d.io
-      name: Wildcard
-    name: pgcat
-    urls:
-    - https://github.com/postgresml/pgcat/releases/download/pgcat-0.2.3/pgcat-0.2.3.tgz
-    version: 0.2.3
-  - apiVersion: v2
-    appVersion: 1.2.0
-    created: "2024-11-02T16:55:33.01802196Z"
-    description: A Helm chart for PgCat a PostgreSQL pooler and proxy (like PgBouncer)
-      with support for sharding, load balancing, failover and mirroring.
-    digest: 106ce6a390c9e8d7fd1efb02b307675f4ed14534bae1ccd1b9e7d121b9a69a74
-    maintainers:
-    - email: support@w6d.io
-      name: Wildcard
-    name: pgcat
-    urls:
-    - https://github.com/postgresml/pgcat/releases/download/pgcat-0.2.2/pgcat-0.2.2.tgz
-    version: 0.2.2
-generated: "2024-11-08T12:07:27.767681762Z"
--- a/pgcat.toml
+++ b/pgcat.toml
@@ -0,0 +1,108 @@
+#
+# 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
+
+# How many connections to allocate per server.
+pool_size = 15
+
+# 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.
+#
+# 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 = 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 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"
--- a/pgcat3.png
+++ b/pgcat3.png
--- a/src/admin.rs
+++ b/src/admin.rs
@@ -0,0 +1,351 @@
+use bytes::{Buf, BufMut, BytesMut};
+use log::{info, trace};
+use tokio::net::tcp::OwnedWriteHalf;
+
+use std::collections::HashMap;
+
+use crate::config::{get_config, parse};
+use crate::errors::Error;
+use crate::messages::*;
+use crate::pool::ConnectionPool;
+use crate::stats::get_stats;
+
+/// Handle admin client
+pub async fn handle_admin(
+    stream: &mut OwnedWriteHalf,
+    mut query: BytesMut,
+    pool: ConnectionPool,
+) -> Result<(), Error> {
+    let code = query.get_u8() as char;
+
+    if code != 'Q' {
+        return Err(Error::ProtocolSyncError);
+    }
+
+    let len = query.get_i32() as usize;
+    let query = String::from_utf8_lossy(&query[..len - 5])
+        .to_string()
+        .to_ascii_uppercase();
+
+    trace!("Admin query: {}", query);
+
+    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
+    }
+}
+
+/// 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 res = BytesMut::new();
+    res.put(row_description(&columns));
+    res.put(data_row(&vec![
+        "databases".to_string(),
+        (pool.databases() + 1).to_string(), // see comment below
+    ]));
+    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(),
+        stats["cl_idle"].to_string(),
+    ]));
+    res.put(data_row(&vec![
+        "used_clients".to_string(),
+        stats["cl_active"].to_string(),
+    ]));
+    res.put(data_row(&vec![
+        "login_clients".to_string(),
+        "0".to_string(),
+    ]));
+    res.put(data_row(&vec![
+        "free_servers".to_string(),
+        stats["sv_idle"].to_string(),
+    ]));
+    res.put(data_row(&vec![
+        "used_servers".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()]));
+    res.put(data_row(&vec!["dns_queries".to_string(), "0".to_string()]));
+    res.put(data_row(&vec!["dns_pending".to_string(), "0".to_string()]));
+
+    res.put(command_complete("SHOW"));
+
+    res.put_u8(b'Z');
+    res.put_i32(5);
+    res.put_u8(b'I');
+
+    write_all_half(stream, res).await
+}
+
+/// 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!["PgCat 0.1.0".to_string()]));
+    res.put(command_complete("SHOW"));
+
+    res.put_u8(b'Z');
+    res.put_i32(5);
+    res.put_u8(b'I');
+
+    write_all_half(stream, res).await
+}
+
+/// 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),
+        ("cl_active", DataType::Numeric),
+        ("cl_waiting", DataType::Numeric),
+        ("cl_cancel_req", DataType::Numeric),
+        ("sv_active", DataType::Numeric),
+        ("sv_idle", DataType::Numeric),
+        ("sv_used", DataType::Numeric),
+        ("sv_tested", DataType::Numeric),
+        ("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));
+
+    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"));
+
+    res.put_u8(b'Z');
+    res.put_i32(5);
+    res.put_u8(b'I');
+
+    write_all_half(stream, res).await
+}
+
+/// 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),
+        ("host", DataType::Text),
+        ("port", DataType::Text),
+        ("database", DataType::Text),
+        ("force_user", DataType::Text),
+        ("pool_size", DataType::Int4),
+        ("min_pool_size", DataType::Int4),
+        ("reserve_pool", DataType::Int4),
+        ("pool_mode", DataType::Text),
+        ("max_connections", DataType::Int4),
+        ("current_connections", DataType::Int4),
+        ("paused", DataType::Int4),
+        ("disabled", DataType::Int4),
+    ];
+
+    let mut res = BytesMut::new();
+
+    // RowDescription
+    res.put(row_description(&columns));
+
+    for shard in 0..pool.shards() {
+        let database_name = &config.shards[&shard.to_string()].database;
+
+        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
+    res.put_u8(b'Z');
+    res.put_i32(5);
+    res.put_u8(b'I');
+
+    write_all_half(stream, res).await
+}
+
+/// Ignore any SET commands the client sends.
+/// This is common initialization done by ORMs.
+async fn ignore_set(stream: &mut OwnedWriteHalf) -> Result<(), Error> {
+    custom_protocol_response_ok(stream, "SET").await
+}
+
+/// RELOAD
+async fn reload(stream: &mut OwnedWriteHalf) -> Result<(), Error> {
+    info!("Reloading config");
+
+    let config = get_config();
+    let path = config.path.clone().unwrap();
+
+    parse(&path).await?;
+
+    let config = get_config();
+
+    config.show();
+
+    let mut res = BytesMut::new();
+
+    // CommandComplete
+    res.put(command_complete("RELOAD"));
+
+    // ReadyForQuery
+    res.put_u8(b'Z');
+    res.put_i32(5);
+    res.put_u8(b'I');
+
+    write_all_half(stream, res).await
+}
+
+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 dynamically.
+    let immutables = ["host", "port", "connect_timeout"];
+
+    // Columns
+    let columns = vec![
+        ("key", DataType::Text),
+        ("value", DataType::Text),
+        ("default", DataType::Text),
+        ("changeable", DataType::Text),
+    ];
+
+    // Response data
+    let mut res = BytesMut::new();
+    res.put(row_description(&columns));
+
+    // DataRow rows
+    for (key, value) in config {
+        let changeable = if immutables.iter().filter(|col| *col == &key).count() == 1 {
+            "no".to_string()
+        } else {
+            "yes".to_string()
+        };
+
+        let row = vec![key, value, "-".to_string(), changeable];
+
+        res.put(data_row(&row));
+    }
+
+    res.put(command_complete("SHOW"));
+
+    res.put_u8(b'Z');
+    res.put_i32(5);
+    res.put_u8(b'I');
+
+    write_all_half(stream, res).await
+}
+
+/// SHOW STATS
+async fn show_stats(stream: &mut OwnedWriteHalf) -> Result<(), Error> {
+    let columns = vec![
+        ("database", DataType::Text),
+        ("total_xact_count", DataType::Numeric),
+        ("total_query_count", DataType::Numeric),
+        ("total_received", DataType::Numeric),
+        ("total_sent", DataType::Numeric),
+        ("total_xact_time", DataType::Numeric),
+        ("total_query_time", DataType::Numeric),
+        ("total_wait_time", DataType::Numeric),
+        ("avg_xact_count", DataType::Numeric),
+        ("avg_query_count", DataType::Numeric),
+        ("avg_recv", DataType::Numeric),
+        ("avg_sent", DataType::Numeric),
+        ("avg_xact_time", DataType::Numeric),
+        ("avg_query_time", DataType::Numeric),
+        ("avg_wait_time", DataType::Numeric),
+    ];
+
+    let stats = get_stats();
+    let mut res = BytesMut::new();
+    res.put(row_description(&columns));
+
+    let mut row = vec![
+        String::from("all"), // TODO: per-database stats,
+    ];
+
+    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"));
+
+    res.put_u8(b'Z');
+    res.put_i32(5);
+    res.put_u8(b'I');
+
+    write_all_half(stream, res).await
+}
--- a/src/client.rs
+++ b/src/client.rs
@@ -0,0 +1,557 @@
+/// Implementation of the PostgreSQL client.
+/// We are pretending to the server in this scenario,
+/// and this module implements that.
+use bytes::{Buf, BufMut, BytesMut};
+use log::{debug, error, trace};
+use tokio::io::{AsyncReadExt, BufReader};
+use tokio::net::{
+    tcp::{OwnedReadHalf, OwnedWriteHalf},
+    TcpStream,
+};
+
+use std::collections::HashMap;
+
+use crate::admin::handle_admin;
+use crate::config::get_config;
+use crate::constants::*;
+use crate::errors::Error;
+use crate::messages::*;
+use crate::pool::{ClientServerMap, ConnectionPool};
+use crate::query_router::{Command, QueryRouter};
+use crate::server::Server;
+use crate::stats::Reporter;
+
+/// The client state. One of these is created per client.
+pub struct Client {
+    // The reads are buffered (8K by default).
+    read: BufReader<OwnedReadHalf>,
+
+    // We buffer the writes ourselves because we know the protocol
+    // better than a stock buffer.
+    write: OwnedWriteHalf,
+
+    // Internal buffer, where we place messages until we have to flush
+    // them to the backend.
+    buffer: BytesMut,
+
+    // The client was started with the sole reason to cancel another running query.
+    cancel_mode: bool,
+
+    // In transaction mode, the connection is released after each transaction.
+    // Session mode has slightly higher throughput per client, but lower capacity.
+    transaction_mode: bool,
+
+    // For query cancellation, the client is given a random process ID and secret on startup.
+    process_id: i32,
+    secret_key: i32,
+
+    // Clients are mapped to servers while they use them. This allows a client
+    // to connect and cancel a query.
+    client_server_map: ClientServerMap,
+
+    // Client parameters, e.g. user, client_encoding, etc.
+    #[allow(dead_code)]
+    parameters: HashMap<String, String>,
+
+    // Statistics
+    stats: Reporter,
+
+    // Clients want to talk to admin
+    admin: bool,
+}
+
+impl Client {
+    /// Given a TCP socket, trick the client into thinking we are
+    /// the Postgres server. Perform the authentication and place
+    /// the client in query-ready mode.
+    pub async fn startup(
+        mut stream: TcpStream,
+        client_server_map: ClientServerMap,
+        server_info: BytesMut,
+        stats: Reporter,
+    ) -> Result<Client, Error> {
+        let config = get_config();
+        let transaction_mode = config.general.pool_mode.starts_with("t");
+        drop(config);
+        loop {
+            trace!("Waiting for StartupMessage");
+
+            // Could be StartupMessage or SSLRequest
+            // which makes this variable length.
+            let len = match stream.read_i32().await {
+                Ok(len) => len,
+                Err(_) => return Err(Error::ClientBadStartup),
+            };
+
+            // Read whatever is left.
+            let mut startup = vec![0u8; len as usize - 4];
+
+            match stream.read_exact(&mut startup).await {
+                Ok(_) => (),
+                Err(_) => return Err(Error::ClientBadStartup),
+            };
+
+            let mut bytes = BytesMut::from(&startup[..]);
+            let code = bytes.get_i32();
+
+            match code {
+                // Client wants SSL. We don't support it at the moment.
+                SSL_REQUEST_CODE => {
+                    trace!("Rejecting SSLRequest");
+
+                    let mut no = BytesMut::with_capacity(1);
+                    no.put_u8(b'N');
+
+                    write_all(&mut stream, no).await?;
+                }
+
+                // Regular startup message.
+                PROTOCOL_VERSION_NUMBER => {
+                    trace!("Got StartupMessage");
+                    let parameters = parse_startup(bytes.clone())?;
+                    let mut user_name: String = String::new();
+                    match parameters.get(&"user") {
+                        Some(&user) => user_name = user,
+                        None => return Err(Error::ClientBadStartup),
+                    }
+                    start_auth(&mut stream, &user_name).await?;
+
+                    // Generate random backend ID and secret key
+                    let process_id: i32 = rand::random();
+                    let secret_key: i32 = rand::random();
+
+                    write_all(&mut stream, server_info).await?;
+                    backend_key_data(&mut stream, process_id, secret_key).await?;
+                    ready_for_query(&mut stream).await?;
+                    trace!("Startup OK");
+
+                    let database = parameters
+                        .get("database")
+                        .unwrap_or(parameters.get("user").unwrap());
+                    let admin = ["pgcat", "pgbouncer"]
+                        .iter()
+                        .filter(|db| *db == &database)
+                        .count()
+                        == 1;
+
+                    // Split the read and write streams
+                    // so we can control buffering.
+                    let (read, write) = stream.into_split();
+
+                    return Ok(Client {
+                        read: BufReader::new(read),
+                        write: write,
+                        buffer: BytesMut::with_capacity(8196),
+                        cancel_mode: false,
+                        transaction_mode: transaction_mode,
+                        process_id: process_id,
+                        secret_key: secret_key,
+                        client_server_map: client_server_map,
+                        parameters: parameters,
+                        stats: stats,
+                        admin: admin,
+                    });
+                }
+
+                // Query cancel request.
+                CANCEL_REQUEST_CODE => {
+                    let (read, write) = stream.into_split();
+
+                    let process_id = bytes.get_i32();
+                    let secret_key = bytes.get_i32();
+
+                    return Ok(Client {
+                        read: BufReader::new(read),
+                        write: write,
+                        buffer: BytesMut::with_capacity(8196),
+                        cancel_mode: true,
+                        transaction_mode: transaction_mode,
+                        process_id: process_id,
+                        secret_key: secret_key,
+                        client_server_map: client_server_map,
+                        parameters: HashMap::new(),
+                        stats: stats,
+                        admin: false,
+                    });
+                }
+
+                _ => {
+                    return Err(Error::ProtocolSyncError);
+                }
+            };
+        }
+    }
+
+    /// Client loop. We handle all messages between the client and the database here.
+    pub async fn handle(&mut self, mut pool: ConnectionPool) -> Result<(), Error> {
+        // The client wants to cancel a query it has issued previously.
+        if self.cancel_mode {
+            trace!("Sending CancelRequest");
+
+            let (process_id, secret_key, address, port) = {
+                let guard = self.client_server_map.lock();
+
+                match guard.get(&(self.process_id, self.secret_key)) {
+                    // Drop the mutex as soon as possible.
+                    // We found the server the client is using for its query
+                    // that it wants to cancel.
+                    Some((process_id, secret_key, address, port)) => (
+                        process_id.clone(),
+                        secret_key.clone(),
+                        address.clone(),
+                        port.clone(),
+                    ),
+
+                    // The client doesn't know / got the wrong server,
+                    // we're closing the connection for security reasons.
+                    None => return Ok(()),
+                }
+            };
+
+            // Opens a new separate connection to the server, sends the backend_id
+            // and secret_key and then closes it for security reasons. No other interactions
+            // take place.
+            return Ok(Server::cancel(&address, &port, process_id, secret_key).await?);
+        }
+
+        let mut query_router = QueryRouter::new();
+
+        // Our custom protocol loop.
+        // We expect the client to either start a transaction with regular queries
+        // or issue commands for our sharding and server selection protocols.
+        loop {
+            trace!("Client idle, waiting for message");
+
+            // Client idle, waiting for messages.
+            self.stats.client_idle(self.process_id);
+
+            // Read a complete message from the client, which normally would be
+            // either a `Q` (query) or `P` (prepare, extended protocol).
+            // We can parse it here before grabbing a server from the pool,
+            // in case the client is sending some control messages, e.g.
+            // SET SHARDING KEY TO 'bigint';
+            let mut message = read_message(&mut self.read).await?;
+
+            // Avoid taking a server if the client just wants to disconnect.
+            if message[0] as char == 'X' {
+                trace!("Client disconnecting");
+                return Ok(());
+            }
+
+            // Handle admin database real quick
+            if self.admin {
+                trace!("Handling admin command");
+                handle_admin(&mut self.write, message, pool.clone()).await?;
+                continue;
+            }
+
+            // Handle all custom protocol commands here.
+            match query_router.try_execute_command(message.clone()) {
+                // Normal query
+                None => {
+                    if query_router.query_parser_enabled() && query_router.role() == None {
+                        query_router.infer_role(message.clone());
+                    }
+                }
+
+                Some((Command::SetShard, _)) => {
+                    custom_protocol_response_ok(&mut self.write, &format!("SET SHARD")).await?;
+                    continue;
+                }
+
+                Some((Command::SetShardingKey, _)) => {
+                    custom_protocol_response_ok(&mut self.write, &format!("SET SHARDING KEY"))
+                        .await?;
+                    continue;
+                }
+
+                Some((Command::SetServerRole, _)) => {
+                    custom_protocol_response_ok(&mut self.write, "SET SERVER ROLE").await?;
+                    continue;
+                }
+
+                Some((Command::ShowServerRole, value)) => {
+                    show_response(&mut self.write, "server role", &value).await?;
+                    continue;
+                }
+
+                Some((Command::ShowShard, value)) => {
+                    show_response(&mut self.write, "shard", &value).await?;
+                    continue;
+                }
+            };
+
+            // Make sure we selected a valid shard.
+            if query_router.shard() >= pool.shards() {
+                error_response(
+                    &mut self.write,
+                    &format!(
+                        "shard '{}' is more than configured '{}'",
+                        query_router.shard(),
+                        pool.shards()
+                    ),
+                )
+                .await?;
+                continue;
+            }
+
+            // Waiting for server connection.
+            self.stats.client_waiting(self.process_id);
+
+            debug!("Waiting for connection from pool");
+
+            // Grab a server from the pool: the client issued a regular query.
+            let connection = match pool.get(query_router.shard(), query_router.role()).await {
+                Ok(conn) => {
+                    debug!("Got connection from pool");
+                    conn
+                }
+                Err(err) => {
+                    error!("Could not get connection from pool: {:?}", err);
+                    error_response(&mut self.write, "could not get connection from the pool")
+                        .await?;
+                    continue;
+                }
+            };
+
+            let mut reference = connection.0;
+            let _address = connection.1;
+            let server = &mut *reference;
+
+            // Claim this server as mine for query cancellation.
+            server.claim(self.process_id, self.secret_key);
+
+            // Client active & server active
+            self.stats.client_active(self.process_id);
+            self.stats.server_active(server.process_id());
+
+            debug!(
+                "Client {:?} talking to server {:?}",
+                self.write.peer_addr().unwrap(),
+                server.address()
+            );
+
+            // Transaction loop. Multiple queries can be issued by the client here.
+            // The connection belongs to the client until the transaction is over,
+            // or until the client disconnects if we are in session mode.
+            loop {
+                let mut message = if message.len() == 0 {
+                    trace!("Waiting for message inside transaction or in session mode");
+
+                    match read_message(&mut self.read).await {
+                        Ok(message) => message,
+                        Err(err) => {
+                            // Client disconnected without warning.
+                            if server.in_transaction() {
+                                // Client left dirty server. Clean up and proceed
+                                // without thrashing this connection.
+                                server.query("ROLLBACK; DISCARD ALL;").await?;
+                            }
+
+                            return Err(err);
+                        }
+                    }
+                } else {
+                    let msg = message.clone();
+                    message.clear();
+                    msg
+                };
+
+                // The message will be forwarded to the server intact. We still would like to
+                // parse it below to figure out what to do with it.
+                let original = message.clone();
+
+                let code = message.get_u8() as char;
+                let _len = message.get_i32() as usize;
+
+                trace!("Message: {}", code);
+
+                match code {
+                    // ReadyForQuery
+                    'Q' => {
+                        debug!("Sending query to server");
+
+                        // TODO: implement retries here for read-only transactions.
+                        server.send(original).await?;
+
+                        // Read all data the server has to offer, which can be multiple messages
+                        // buffered in 8196 bytes chunks.
+                        loop {
+                            // TODO: implement retries here for read-only transactions.
+                            let response = server.recv().await?;
+
+                            // Send server reply to the client.
+                            match write_all_half(&mut self.write, response).await {
+                                Ok(_) => (),
+                                Err(err) => {
+                                    server.mark_bad();
+                                    return Err(err);
+                                }
+                            };
+
+                            if !server.is_data_available() {
+                                break;
+                            }
+                        }
+
+                        // Report query executed statistics.
+                        self.stats.query();
+
+                        // The transaction is over, we can release the connection back to the pool.
+                        if !server.in_transaction() {
+                            // Report transaction executed statistics.
+                            self.stats.transaction();
+
+                            // Release server back to the pool if we are in transaction mode.
+                            // If we are in session mode, we keep the server until the client disconnects.
+                            if self.transaction_mode {
+                                self.stats.server_idle(server.process_id());
+                                break;
+                            }
+                        }
+                    }
+
+                    // Terminate
+                    'X' => {
+                        // Client closing. Rollback and clean up
+                        // connection before releasing into the pool.
+                        // Pgbouncer closes the connection which leads to
+                        // connection thrashing when clients misbehave.
+                        // This pool will protect the database. :salute:
+                        if server.in_transaction() {
+                            server.query("ROLLBACK; DISCARD ALL;").await?;
+                        }
+
+                        return Ok(());
+                    }
+
+                    // Parse
+                    // The query with placeholders is here, e.g. `SELECT * FROM users WHERE email = $1 AND active = $2`.
+                    'P' => {
+                        self.buffer.put(&original[..]);
+                    }
+
+                    // Bind
+                    // The placeholder's replacements are here, e.g. 'user@email.com' and 'true'
+                    'B' => {
+                        self.buffer.put(&original[..]);
+                    }
+
+                    // Describe
+                    // Command a client can issue to describe a previously prepared named statement.
+                    'D' => {
+                        self.buffer.put(&original[..]);
+                    }
+
+                    // Execute
+                    // Execute a prepared statement prepared in `P` and bound in `B`.
+                    'E' => {
+                        self.buffer.put(&original[..]);
+                    }
+
+                    // Sync
+                    // Frontend (client) is asking for the query result now.
+                    'S' => {
+                        debug!("Sending query to server");
+
+                        self.buffer.put(&original[..]);
+
+                        // TODO: retries for read-only transactions.
+                        server.send(self.buffer.clone()).await?;
+
+                        self.buffer.clear();
+
+                        // Read all data the server has to offer, which can be multiple messages
+                        // buffered in 8196 bytes chunks.
+                        loop {
+                            // TODO: retries for read-only transactions
+                            let response = server.recv().await?;
+
+                            match write_all_half(&mut self.write, response).await {
+                                Ok(_) => (),
+                                Err(err) => {
+                                    server.mark_bad();
+                                    return Err(err);
+                                }
+                            };
+
+                            if !server.is_data_available() {
+                                break;
+                            }
+                        }
+
+                        // Report query executed statistics.
+                        self.stats.query();
+
+                        // Release server back to the pool if we are in transaction mode.
+                        // If we are in session mode, we keep the server until the client disconnects.
+                        if !server.in_transaction() {
+                            self.stats.transaction();
+
+                            if self.transaction_mode {
+                                self.stats.server_idle(server.process_id());
+                                break;
+                            }
+                        }
+                    }
+
+                    // CopyData
+                    'd' => {
+                        // Forward the data to the server,
+                        // don't buffer it since it can be rather large.
+                        server.send(original).await?;
+                    }
+
+                    // CopyDone or CopyFail
+                    // Copy is done, successfully or not.
+                    'c' | 'f' => {
+                        server.send(original).await?;
+
+                        let response = server.recv().await?;
+
+                        match write_all_half(&mut self.write, response).await {
+                            Ok(_) => (),
+                            Err(err) => {
+                                server.mark_bad();
+                                return Err(err);
+                            }
+                        };
+
+                        // Release server back to the pool if we are in transaction mode.
+                        // If we are in session mode, we keep the server until the client disconnects.
+                        if !server.in_transaction() {
+                            self.stats.transaction();
+
+                            if self.transaction_mode {
+                                self.stats.server_idle(server.process_id());
+                                break;
+                            }
+                        }
+                    }
+
+                    // Some unexpected message. We either did not implement the protocol correctly
+                    // or this is not a Postgres client we're talking to.
+                    _ => {
+                        error!("Unexpected code: {}", code);
+                    }
+                }
+            }
+
+            // The server is no longer bound to us, we can't cancel it's queries anymore.
+            debug!("Releasing server back into the pool");
+            self.release();
+        }
+    }
+
+    /// Release the server from being mine. I can't cancel its queries anymore.
+    pub fn release(&self) {
+        let mut guard = self.client_server_map.lock();
+        guard.remove(&(self.process_id, self.secret_key));
+    }
+}
+
+impl Drop for Client {
+    fn drop(&mut self) {
+        self.stats.client_disconnecting(self.process_id);
+    }
+}
--- a/src/config.rs
+++ b/src/config.rs
@@ -0,0 +1,372 @@
+use arc_swap::{ArcSwap, Guard};
+use log::{error, info};
+use once_cell::sync::Lazy;
+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;
+
+static CONFIG: Lazy<ArcSwap<Config>> = Lazy::new(|| ArcSwap::from_pointee(Config::default()));
+
+#[derive(Clone, PartialEq, Deserialize, Hash, std::cmp::Eq, Debug, Copy)]
+pub enum Role {
+    Primary,
+    Replica,
+}
+
+impl ToString for Role {
+    fn to_string(&self) -> String {
+        match *self {
+            Role::Primary => "primary".to_string(),
+            Role::Replica => "replica".to_string(),
+        }
+    }
+}
+
+impl PartialEq<Option<Role>> for Role {
+    fn eq(&self, other: &Option<Role>) -> bool {
+        match other {
+            None => true,
+            Some(role) => *self == *role,
+        }
+    }
+}
+
+impl PartialEq<Role> for Option<Role> {
+    fn eq(&self, other: &Role) -> bool {
+        match *self {
+            None => true,
+            Some(role) => role == *other,
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Hash, std::cmp::Eq, Debug)]
+pub struct Address {
+    pub host: String,
+    pub port: String,
+    pub shard: usize,
+    pub role: Role,
+    pub replica_number: usize,
+}
+
+impl Default for Address {
+    fn default() -> Address {
+        Address {
+            host: String::from("127.0.0.1"),
+            port: String::from("5432"),
+            shard: 0,
+            replica_number: 0,
+            role: Role::Replica,
+        }
+    }
+}
+
+impl Address {
+    pub fn name(&self) -> String {
+        match self.role {
+            Role::Primary => format!("shard_{}_primary", self.shard),
+
+            Role::Replica => format!("shard_{}_replica_{}", self.shard, self.replica_number),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Hash, std::cmp::Eq, Deserialize, Debug)]
+pub struct User {
+    pub name: String,
+    pub password: String,
+}
+
+impl Default for User {
+    fn default() -> User {
+        User {
+            name: String::from("postgres"),
+            password: String::new(),
+        }
+    }
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct General {
+    pub host: String,
+    pub port: i16,
+    pub pool_size: u32,
+    pub pool_mode: String,
+    pub connect_timeout: u64,
+    pub healthcheck_timeout: u64,
+    pub ban_time: i64,
+    pub statsd_address: String,
+}
+
+impl Default for General {
+    fn default() -> General {
+        General {
+            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"),
+        }
+    }
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Shard {
+    pub servers: Vec<(String, u16, String)>,
+    pub database: String,
+}
+
+impl Default for Shard {
+    fn default() -> Shard {
+        Shard {
+            servers: vec![(String::from("localhost"), 5432, String::from("primary"))],
+            database: String::from("postgres"),
+        }
+    }
+}
+
+#[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 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: Some(String::from("pgcat.toml")),
+            general: General::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> {
+        HashMap::from([
+            ("host".to_string(), config.general.host.to_string()),
+            ("port".to_string(), config.general.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(),
+                config.general.connect_timeout.to_string(),
+            ),
+            (
+                "healthcheck_timeout".to_string(),
+                config.general.healthcheck_timeout.to_string(),
+            ),
+            ("ban_time".to_string(), config.general.ban_time.to_string()),
+            (
+                "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 {
+    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!("Sharding function: {}", self.query_router.sharding_function);
+        info!("Number of shards: {}", self.shards.len());
+    }
+}
+
+pub fn get_config() -> Guard<Arc<Config>> {
+    CONFIG.load()
+}
+
+/// Parse the config.
+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 mut config: Config = match toml::from_str(&contents) {
+        Ok(config) => config,
+        Err(err) => {
+            error!("Could not parse config file: {}", err.to_string());
+            return Err(Error::BadConfig);
+        }
+    };
+
+    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);
+        }
+    };
+
+    // 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)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_config() {
+        parse("pgcat.toml").await.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
@@ -0,0 +1,27 @@
+/// Various protocol constants, as defined in
+/// 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;
+
+// SSLRequest: used to indicate we want an SSL connection.
+pub const SSL_REQUEST_CODE: i32 = 80877103;
+
+// CancelRequest: the cancel request code.
+pub const CANCEL_REQUEST_CODE: i32 = 80877102;
+
+// AuthenticationMD5Password
+pub const MD5_ENCRYPTED_PASSWORD: i32 = 5;
+
+// AuthenticationOk
+pub const AUTHENTICATION_SUCCESSFUL: i32 = 0;
+
+// ErrorResponse: A code identifying the field type; if zero, this is the message terminator and no string follows.
+pub const MESSAGE_TERMINATOR: u8 = 0;
+
+//
+// Data types
+//
+pub const _OID_INT8: i32 = 20; // bigint
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -0,0 +1,14 @@
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    SocketError,
+    // ClientDisconnected,
+    ClientBadStartup,
+    ProtocolSyncError,
+    ServerError,
+    // ServerTimeout,
+    // DirtyServer,
+    BadConfig,
+    BadUserList,
+    AllServersDown,
+    AuthenticationError
+}
--- a/src/main.rs
+++ b/src/main.rs
@@ -0,0 +1,263 @@
+// 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
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+extern crate arc_swap;
+extern crate async_trait;
+extern crate bb8;
+extern crate bytes;
+extern crate env_logger;
+extern crate log;
+extern crate md5;
+extern crate num_cpus;
+extern crate once_cell;
+extern crate serde;
+extern crate serde_derive;
+extern crate sqlparser;
+extern crate statsd;
+extern crate tokio;
+extern crate toml;
+
+use log::{error, info};
+use parking_lot::Mutex;
+use tokio::net::TcpListener;
+use tokio::{
+    signal,
+    signal::unix::{signal as unix_signal, SignalKind},
+    sync::mpsc,
+};
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+mod admin;
+mod client;
+mod config;
+mod userlist;
+mod constants;
+mod errors;
+mod messages;
+mod pool;
+mod query_router;
+mod server;
+mod sharding;
+mod stats;
+
+// 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::init();
+    info!("Welcome to PgCat! Meow.");
+
+    // Prepare regexes
+    if !query_router::QueryRouter::setup() {
+        error!("Could not setup query router");
+        return;
+    }
+
+    let args = std::env::args().collect::<Vec<String>>();
+
+    let config_file = if args.len() == 2 {
+        args[1].to_string()
+    } else {
+        String::from("pgcat.toml")
+    };
+
+    // Prepare the config
+    match config::parse(&config_file).await {
+        Ok(_) => (),
+        Err(err) => {
+            error!("Config parse error: {:?}", err);
+            return;
+        }
+    };
+
+    // Prepare user list
+    match userlist::parse("userlist.json").await {
+        Ok(_) => (),
+        Err(err) => {
+            error!("Userlist parse error: {:?}", err);
+            return;
+        }
+    };
+
+    let config = get_config();
+
+    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);
+            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()));
+
+    // 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(rx, collector_tx);
+        stats_collector.collect().await;
+    });
+
+    let mut pool =
+        ConnectionPool::from_config(client_server_map.clone(), Reporter::new(tx.clone())).await;
+
+    let server_info = match pool.validate().await {
+        Ok(info) => info,
+        Err(err) => {
+            error!("Could not validate connection pool: {:?}", err);
+            return;
+        }
+    };
+
+    info!("Waiting for clients");
+
+    // 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());
+
+            let (socket, addr) = match listener.accept().await {
+                Ok((socket, addr)) => (socket, addr),
+                Err(err) => {
+                    error!("{:?}", err);
+                    continue;
+                }
+            };
+
+            // 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(mut client) => {
+                        info!("Client {:?} connected", addr);
+                        match client.handle(pool).await {
+                            Ok(()) => {
+                                let duration = chrono::offset::Utc::now().naive_utc() - start;
+
+                                info!(
+                                    "Client {:?} disconnected, session duration: {}",
+                                    addr,
+                                    format_duration(&duration)
+                                );
+                            }
+
+                            Err(err) => {
+                                error!("Client disconnected with error: {:?}", err);
+                                client.release();
+                            }
+                        }
+                    }
+
+                    Err(err) => {
+                        error!("Client failed to login: {:?}", err);
+                    }
+                };
+            });
+        }
+    });
+
+    // 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
@@ -0,0 +1,512 @@
+/// 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, BufReader};
+use tokio::net::{
+    tcp::{OwnedReadHalf, OwnedWriteHalf},
+    TcpStream,
+};
+use log::{error};
+
+use crate::errors::Error;
+use std::collections::HashMap;
+
+use rand::Rng;
+
+use crate::userlist::get_user_list;
+
+
+/// Postgres data type mappings
+/// used in RowDescription ('T') message.
+pub enum DataType {
+    Text,
+    Int4,
+    Numeric,
+}
+
+impl From<&DataType> for i32 {
+    fn from(data_type: &DataType) -> i32 {
+        match data_type {
+            DataType::Text => 25,
+            DataType::Int4 => 23,
+            DataType::Numeric => 1700,
+        }
+    }
+}
+
+/**
+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_name: &String) -> Result<(), Error> {
+    let mut rng = rand::thread_rng();
+
+    //Generate random 4 byte salt
+    let salt = rng.gen::<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_name, &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_name: &String, 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: String = String::new();
+    match user_list.get(&user_name) {
+        Some(&p) => password = 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_name.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(stream: &mut TcpStream) -> Result<(), Error> {
+    let mut auth_ok = BytesMut::with_capacity(9);
+
+    auth_ok.put_u8(b'R');
+    auth_ok.put_i32(8);
+    auth_ok.put_i32(0);
+
+    Ok(write_all(stream, auth_ok).await?)
+}
+
+/// Give the client the process_id and secret we generated
+/// used in query cancellation.
+pub async fn backend_key_data(
+    stream: &mut TcpStream,
+    backend_id: i32,
+    secret_key: i32,
+) -> Result<(), Error> {
+    let mut key_data = BytesMut::from(&b"K"[..]);
+    key_data.put_i32(12);
+    key_data.put_i32(backend_id);
+    key_data.put_i32(secret_key);
+
+    Ok(write_all(stream, key_data).await?)
+}
+
+/// Construct a `Q`: Query message.
+pub fn simple_query(query: &str) -> BytesMut {
+    let mut res = BytesMut::from(&b"Q"[..]);
+    let query = format!("{}\0", query);
+
+    res.put_i32(query.len() as i32 + 4);
+    res.put_slice(&query.as_bytes());
+
+    res
+}
+
+/// Tell the client we're ready for another query.
+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);
+    bytes.put_u8(b'I'); // Idle
+
+    Ok(write_all(stream, bytes).await?)
+}
+
+/// Send the startup packet the server. We're pretending we're a Pg client.
+/// This tells the server which user we are and what database we want.
+pub async fn startup(stream: &mut TcpStream, user: &str, database: &str) -> Result<(), Error> {
+    let mut bytes = BytesMut::with_capacity(25);
+
+    bytes.put_i32(196608); // Protocol number
+
+    // User
+    bytes.put(&b"user\0"[..]);
+    bytes.put_slice(&user.as_bytes());
+    bytes.put_u8(0);
+
+    // Database
+    bytes.put(&b"database\0"[..]);
+    bytes.put_slice(&database.as_bytes());
+    bytes.put_u8(0);
+    bytes.put_u8(0); // Null terminator
+
+    let len = bytes.len() as i32 + 4i32;
+
+    let mut startup = BytesMut::with_capacity(len as usize);
+
+    startup.put_i32(len);
+    startup.put(bytes);
+
+    match stream.write_all(&startup).await {
+        Ok(_) => Ok(()),
+        Err(_) => return Err(Error::SocketError),
+    }
+}
+
+/// Parse the params the server sends as a key/value format.
+pub fn parse_params(mut bytes: BytesMut) -> Result<HashMap<String, String>, Error> {
+    let mut result = HashMap::new();
+    let mut buf = Vec::new();
+    let mut tmp = String::new();
+
+    while bytes.has_remaining() {
+        let mut c = bytes.get_u8();
+
+        // Null-terminated C-strings.
+        while c != 0 {
+            tmp.push(c as char);
+            c = bytes.get_u8();
+        }
+
+        if tmp.len() > 0 {
+            buf.push(tmp.clone());
+            tmp.clear();
+        }
+    }
+
+    // Expect pairs of name and value
+    // and at least one pair to be present.
+    if buf.len() % 2 != 0 || buf.len() < 2 {
+        return Err(Error::ClientBadStartup);
+    }
+
+    let mut i = 0;
+    while i < buf.len() {
+        let name = buf[i].clone();
+        let value = buf[i + 1].clone();
+        let _ = result.insert(name, value);
+        i += 2;
+    }
+
+    Ok(result)
+}
+
+/// Parse StartupMessage parameters.
+/// e.g. user, database, application_name, etc.
+pub fn parse_startup(bytes: BytesMut) -> Result<HashMap<String, String>, Error> {
+    let result = parse_params(bytes)?;
+
+    // Minimum required parameters
+    // I want to have the user at the very minimum, according to the protocol spec.
+    if !result.contains_key("user") {
+        return Err(Error::ClientBadStartup);
+    }
+
+    Ok(result)
+}
+
+/// 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
+    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);
+
+    let mut password = format!("md5{:x}", md5.finalize())
+        .chars()
+        .map(|x| x as u8)
+        .collect::<Vec<u8>>();
+    password.push(0);
+
+    let mut message = BytesMut::with_capacity(password.len() as usize + 5);
+
+    message.put_u8(b'p');
+    message.put_i32(password.len() as i32 + 4);
+    message.put_slice(&password[..]);
+
+    Ok(write_all(stream, message).await?)
+}
+
+/// 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(
+    stream: &mut OwnedWriteHalf,
+    message: &str,
+) -> Result<(), Error> {
+    let mut res = BytesMut::with_capacity(25);
+
+    let set_complete = BytesMut::from(&format!("{}\0", message)[..]);
+    let len = (set_complete.len() + 4) as i32;
+
+    // CommandComplete
+    res.put_u8(b'C');
+    res.put_i32(len);
+    res.put_slice(&set_complete[..]);
+
+    // 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(stream: &mut OwnedWriteHalf, message: &str) -> Result<(), Error> {
+    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"58000\0"[..]); // system_error, see Appendix A.
+
+    // The short error message.
+    error.put_u8(b'M');
+    error.put_slice(&format!("{}\0", message).as_bytes());
+
+    // 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() + 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?)
+}
+
+/// Respond to a SHOW SHARD command.
+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
+    // 3. CommandComplete
+    // 4. ReadyForQuery
+
+    // The final messages sent to the client
+    let mut res = BytesMut::new();
+
+    // RowDescription
+    res.put(row_description(&vec![(name, DataType::Text)]));
+
+    // DataRow
+    res.put(data_row(&vec![value.to_string()]));
+
+    // CommandComplete
+    res.put(command_complete("SELECT 1"));
+
+    // 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 {
+    let mut res = BytesMut::new();
+    let mut row_desc = BytesMut::new();
+
+    // how many colums we are storing
+    row_desc.put_i16(columns.len() as i16);
+
+    for (name, data_type) in columns {
+        // Column name
+        row_desc.put_slice(&format!("{}\0", name).as_bytes());
+
+        // Doesn't belong to any table
+        row_desc.put_i32(0);
+
+        // Doesn't belong to any table
+        row_desc.put_i16(0);
+
+        // Text
+        row_desc.put_i32(data_type.into());
+
+        // Text size = variable (-1)
+        let type_size = match data_type {
+            DataType::Text => -1,
+            DataType::Int4 => 4,
+            DataType::Numeric => -1,
+        };
+
+        row_desc.put_i16(type_size);
+
+        // Type modifier: none that I know
+        row_desc.put_i32(-1);
+
+        // Format being used: text (0), binary (1)
+        row_desc.put_i16(0);
+    }
+
+    res.put_u8(b'T');
+    res.put_i32(row_desc.len() as i32 + 4);
+    res.put(row_desc);
+
+    res
+}
+
+pub fn data_row(row: &Vec<String>) -> BytesMut {
+    let mut res = BytesMut::new();
+    let mut data_row = BytesMut::new();
+
+    data_row.put_i16(row.len() as i16);
+
+    for column in row {
+        let column = column.as_bytes();
+        data_row.put_i32(column.len() as i32);
+        data_row.put_slice(&column);
+    }
+
+    res.put_u8(b'D');
+    res.put_i32(data_row.len() as i32 + 4);
+    res.put(data_row);
+
+    res
+}
+
+pub fn command_complete(command: &str) -> BytesMut {
+    let cmd = BytesMut::from(format!("{}\0", command).as_bytes());
+    let mut res = BytesMut::new();
+    res.put_u8(b'C');
+    res.put_i32(cmd.len() as i32 + 4);
+    res.put(cmd);
+    res
+}
+
+/// Write all data in the buffer to the TcpStream.
+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),
+    }
+}
+
+/// Write all the data in the buffer to the TcpStream, write owned half (see mpsc).
+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),
+    }
+}
+
+/// Read a complete message from the socket.
+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),
+    };
+
+    let len = match stream.read_i32().await {
+        Ok(len) => len,
+        Err(_) => return Err(Error::SocketError),
+    };
+
+    let mut buf = vec![0u8; len as usize - 4];
+
+    match stream.read_exact(&mut buf).await {
+        Ok(_) => (),
+        Err(_) => return Err(Error::SocketError),
+    };
+
+    let mut bytes = BytesMut::with_capacity(len as usize + 1);
+
+    bytes.put_u8(code);
+    bytes.put_i32(len);
+    bytes.put_slice(&buf);
+
+    Ok(bytes)
+}
--- a/src/pool.rs
+++ b/src/pool.rs
@@ -0,0 +1,437 @@
+/// 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 parking_lot::{Mutex, RwLock};
+
+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;
+
+// Banlist: bad servers go in here.
+pub type BanList = Arc<RwLock<Vec<HashMap<Address, NaiveDateTime>>>>;
+pub type ClientServerMap = Arc<Mutex<HashMap<(i32, i32), (i32, i32, String, String)>>>;
+
+#[derive(Clone, Debug)]
+pub struct ConnectionPool {
+    databases: Vec<Vec<Pool<ServerPool>>>,
+    addresses: Vec<Vec<Address>>,
+    round_robin: usize,
+    banlist: BanList,
+    stats: Reporter,
+}
+
+impl ConnectionPool {
+    /// 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());
+
+        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;
+
+            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;
+                }
+
+                let manager = ServerPool::new(
+                    address.clone(),
+                    config.user.clone(),
+                    &shard.database,
+                    client_server_map.clone(),
+                    stats.clone(),
+                );
+
+                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();
+
+                pools.push(pool);
+                servers.push(address);
+            }
+
+            shards.push(pools);
+            addresses.push(servers);
+            banlist.push(HashMap::new());
+        }
+
+        assert_eq!(shards.len(), addresses.len());
+        let address_len = addresses.len();
+
+        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.
+    /// Return server information we will pass to the clients
+    /// when they connect.
+    /// This also warms up the pool for clients that connect when
+    /// the pooler starts up.
+    pub async fn validate(&mut self) -> Result<BytesMut, Error> {
+        let mut server_infos = Vec::new();
+
+        for shard in 0..self.shards() {
+            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);
+                        continue;
+                    }
+                };
+
+                let mut proxy = connection.0;
+                let address = connection.1;
+                let server = &mut *proxy;
+
+                let server_info = server.server_info();
+
+                if server_infos.len() > 0 {
+                    // Compare against the last server checked.
+                    if server_info != server_infos[server_infos.len() - 1] {
+                        warn!(
+                            "{:?} has different server configuration than the last server",
+                            address
+                        );
+                    }
+                }
+
+                server_infos.push(server_info);
+            }
+        }
+
+        // TODO: compare server information to make sure
+        // all shards are running identical configurations.
+        if server_infos.len() == 0 {
+            return Err(Error::AllServersDown);
+        }
+
+        Ok(server_infos[0].clone())
+    }
+
+    /// Get a connection from the pool.
+    pub async fn get(
+        &mut self,
+        shard: usize,
+        role: Option<Role>,
+    ) -> Result<(PooledConnection<'_, ServerPool>, Address), Error> {
+        let now = Instant::now();
+        let addresses = &self.addresses[shard];
+
+        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,
+
+            // Replicas get to try as many times as there are replicas
+            // and connections in the pool.
+            _ => addresses.len(),
+        };
+
+        debug!("Allowed attempts for {:?}: {}", role, allowed_attempts);
+
+        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;
+            }
+
+            allowed_attempts -= 1;
+
+            if self.is_banned(address, shard, role) {
+                continue;
+            }
+
+            // Check if we can connect
+            let mut conn = match self.databases[shard][index].get().await {
+                Ok(conn) => conn,
+                Err(err) => {
+                    error!("Banning replica {}, error: {:?}", index, err);
+                    self.ban(address, shard);
+                    continue;
+                }
+            };
+
+            // // Check if this server is alive with a health check
+            let server = &mut *conn;
+            let healthcheck_timeout = get_config().general.healthcheck_timeout;
+
+            self.stats.server_tested(server.process_id());
+
+            match tokio::time::timeout(
+                tokio::time::Duration::from_millis(healthcheck_timeout),
+                server.query("SELECT 1"),
+            )
+            .await
+            {
+                // Check if health check succeeded
+                Ok(res) => match res {
+                    Ok(_) => {
+                        self.stats.checkout_time(now.elapsed().as_micros());
+                        self.stats.server_idle(conn.process_id());
+                        return Ok((conn, address.clone()));
+                    }
+                    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, shard);
+                        continue;
+                    }
+                },
+                // 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, shard);
+                    continue;
+                }
+            }
+        }
+
+        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, shard: usize) {
+        error!("Banning {:?}", address);
+        let now = chrono::offset::Utc::now().naive_utc();
+        let mut guard = self.banlist.write();
+        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, shard: usize) {
+        let mut guard = self.banlist.write();
+        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, shard: usize, role: Option<Role>) -> bool {
+        let replicas_available = match role {
+            Some(Role::Replica) => self.addresses[shard]
+                .iter()
+                .filter(|addr| addr.role == Role::Replica)
+                .count(),
+            None => self.addresses[shard].len(),
+            Some(Role::Primary) => return false, // Primary cannot be banned.
+        };
+
+        debug!("Available targets for {:?}: {}", role, replicas_available);
+
+        let guard = self.banlist.read();
+
+        // Everything is banned = nothing is banned.
+        if guard[shard].len() == replicas_available {
+            drop(guard);
+            let mut guard = self.banlist.write();
+            guard[shard].clear();
+            drop(guard);
+            warn!("Unbanning all replicas.");
+            return false;
+        }
+
+        // I expect this to miss 99.9999% of the time.
+        match guard[shard].get(address) {
+            Some(timestamp) => {
+                let now = chrono::offset::Utc::now().naive_utc();
+                let config = get_config();
+
+                // Ban expired.
+                if now.timestamp() - timestamp.timestamp() > config.general.ban_time {
+                    drop(guard);
+                    warn!("Unbanning {:?}", address);
+                    let mut guard = self.banlist.write();
+                    guard[shard].remove(address);
+                    false
+                } else {
+                    debug!("{:?} is banned", address);
+                    true
+                }
+            }
+
+            None => {
+                debug!("{:?} is ok", address);
+                false
+            }
+        }
+    }
+
+    pub fn shards(&self) -> usize {
+        self.databases.len()
+    }
+
+    pub fn servers(&self, shard: usize) -> usize {
+        self.addresses[shard].len()
+    }
+
+    pub fn databases(&self) -> usize {
+        let mut databases = 0;
+        for shard in 0..self.shards() {
+            databases += self.servers(shard);
+        }
+        databases
+    }
+
+    pub fn pool_state(&self, shard: usize, server: usize) -> bb8::State {
+        self.databases[shard][server].state()
+    }
+
+    pub fn address(&self, shard: usize, server: usize) -> &Address {
+        &self.addresses[shard][server]
+    }
+}
+
+pub struct ServerPool {
+    address: Address,
+    user: User,
+    database: String,
+    client_server_map: ClientServerMap,
+    stats: Reporter,
+}
+
+impl ServerPool {
+    pub fn new(
+        address: Address,
+        user: User,
+        database: &str,
+        client_server_map: ClientServerMap,
+        stats: Reporter,
+    ) -> ServerPool {
+        ServerPool {
+            address: address,
+            user: user,
+            database: database.to_string(),
+            client_server_map: client_server_map,
+            stats: stats,
+        }
+    }
+}
+
+#[async_trait]
+impl ManageConnection for ServerPool {
+    type Connection = Server;
+    type Error = Error;
+
+    /// Attempts to create a new connection.
+    async fn connect(&self) -> Result<Self::Connection, Self::Error> {
+        info!(
+            "Creating a new connection to {:?} using user {:?}",
+            self.address, self.user.name
+        );
+
+        // 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(
+            &self.address,
+            &self.user,
+            &self.database,
+            self.client_server_map.clone(),
+            self.stats.clone(),
+        )
+        .await
+        {
+            Ok(conn) => {
+                // Remove the temporary process_id from the stats.
+                self.stats.server_disconnecting(process_id);
+                Ok(conn)
+            }
+            Err(err) => {
+                // 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 PooledConnection<'_, Self>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    /// Synchronously determine if the connection is no longer usable, if possible.
+    fn has_broken(&self, conn: &mut Self::Connection) -> bool {
+        conn.is_bad()
+    }
+}
--- a/src/query_router.rs
+++ b/src/query_router.rs
@@ -0,0 +1,566 @@
+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};
+use log::{debug, error};
+use once_cell::sync::OnceCell;
+use regex::{Regex, RegexSet};
+use sqlparser::ast::Statement::{Query, StartTransaction};
+use sqlparser::dialect::PostgreSqlDialect;
+use sqlparser::parser::Parser;
+
+const CUSTOM_SQL_REGEXES: [&str; 5] = [
+    r"(?i)^ *SET SHARDING KEY TO '?([0-9]+)'? *;? *$",
+    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 *;? *$",
+];
+
+#[derive(PartialEq, Debug)]
+pub enum Command {
+    SetShardingKey,
+    SetShard,
+    ShowShard,
+    SetServerRole,
+    ShowServerRole,
+}
+
+// Quick test
+static CUSTOM_SQL_REGEX_SET: OnceCell<RegexSet> = OnceCell::new();
+
+// Capture value
+static CUSTOM_SQL_REGEX_LIST: OnceCell<Vec<Regex>> = OnceCell::new();
+
+pub struct QueryRouter {
+    // 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>,
+
+    // Should we be talking to a primary or a replica?
+    active_role: Option<Role>,
+
+    // Include the primary into the replica pool?
+    primary_reads_enabled: bool,
+
+    // Should we try to parse queries?
+    query_parser_enabled: bool,
+
+    // Which sharding function are we using?
+    sharding_function: ShardingFunction,
+}
+
+impl QueryRouter {
+    pub fn setup() -> bool {
+        let set = match RegexSet::new(&CUSTOM_SQL_REGEXES) {
+            Ok(rgx) => rgx,
+            Err(err) => {
+                error!("QueryRouter::setup Could not compile regex set: {:?}", err);
+                return false;
+            }
+        };
+
+        let list: Vec<_> = CUSTOM_SQL_REGEXES
+            .iter()
+            .map(|rgx| Regex::new(rgx).unwrap())
+            .collect();
+
+        // Impossible
+        if list.len() != set.len() {
+            return false;
+        }
+
+        match CUSTOM_SQL_REGEX_LIST.set(list) {
+            Ok(_) => true,
+            Err(_) => return false,
+        };
+
+        match CUSTOM_SQL_REGEX_SET.set(set) {
+            Ok(_) => true,
+            Err(_) => false,
+        }
+    }
+
+    pub fn new() -> QueryRouter {
+        let config = get_config();
+
+        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;
+
+        if code != 'Q' {
+            return None;
+        }
+
+        let len = buf.get_i32() as usize;
+        let query = String::from_utf8_lossy(&buf[..len - 5]).to_string(); // Ignore the terminating NULL.
+
+        let regex_set = match CUSTOM_SQL_REGEX_SET.get() {
+            Some(regex_set) => regex_set,
+            None => return None,
+        };
+
+        let regex_list = match CUSTOM_SQL_REGEX_LIST.get() {
+            Some(regex_list) => regex_list,
+            None => return None,
+        };
+
+        let matches: Vec<_> = regex_set.matches(&query).into_iter().collect();
+
+        if matches.len() != 1 {
+            return None;
+        }
+
+        let command = match matches[0] {
+            0 => Command::SetShardingKey,
+            1 => Command::SetShard,
+            2 => Command::ShowShard,
+            3 => Command::SetServerRole,
+            4 => Command::ShowServerRole,
+            _ => unreachable!(),
+        };
+
+        let mut value = match command {
+            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, 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(),
+                        None => return None,
+                    },
+                    None => return None,
+                }
+            }
+
+            Command::ShowShard => self.shard().to_string(),
+            Command::ShowServerRole => match self.active_role {
+                Some(Role::Primary) => String::from("primary"),
+                Some(Role::Replica) => String::from("replica"),
+                None => {
+                    if self.query_parser_enabled {
+                        String::from("auto")
+                    } else {
+                        String::from("any")
+                    }
+                }
+            },
+        };
+
+        match command {
+            Command::SetShardingKey => {
+                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 = Some(value.parse::<usize>().unwrap());
+            }
+
+            Command::SetServerRole => {
+                self.active_role = match value.to_ascii_lowercase().as_ref() {
+                    "primary" => {
+                        self.query_parser_enabled = false;
+                        Some(Role::Primary)
+                    }
+
+                    "replica" => {
+                        self.query_parser_enabled = false;
+                        Some(Role::Replica)
+                    }
+
+                    "any" => {
+                        self.query_parser_enabled = false;
+                        None
+                    }
+
+                    "auto" => {
+                        self.query_parser_enabled = true;
+                        None
+                    }
+
+                    "default" => {
+                        // 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
+                    }
+
+                    _ => unreachable!(),
+                };
+            }
+
+            _ => (),
+        }
+
+        Some((command, value))
+    }
+
+    /// 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 {
+        let code = buf.get_u8() as char;
+        let len = buf.get_i32() as usize;
+
+        let query = match code {
+            'Q' => {
+                let query = String::from_utf8_lossy(&buf[..len - 5]).to_string();
+                debug!("Query: '{}'", query);
+                query
+            }
+
+            'P' => {
+                let mut start = 0;
+                let mut end;
+
+                // Skip the name of the prepared statement.
+                while buf[start] != 0 && start < buf.len() {
+                    start += 1;
+                }
+                start += 1; // Skip terminating null
+
+                // Find the end of the prepared stmt (\0)
+                end = start;
+                while buf[end] != 0 && end < buf.len() {
+                    end += 1;
+                }
+
+                let query = String::from_utf8_lossy(&buf[start..end]).to_string();
+
+                debug!("Prepared statement: '{}'", query);
+
+                query.replace("$", "") // Remove placeholders turning them into "values"
+            }
+            _ => return false,
+        };
+
+        let ast = match Parser::parse_sql(&PostgreSqlDialect {}, &query) {
+            Ok(ast) => ast,
+            Err(err) => {
+                debug!("{}", err.to_string());
+                return false;
+            }
+        };
+
+        if ast.len() == 0 {
+            return false;
+        }
+
+        match ast[0] {
+            // All transactions go to the primary, probably a write.
+            StartTransaction { .. } => {
+                self.active_role = Some(Role::Primary);
+            }
+
+            // Likely a read-only query
+            Query { .. } => {
+                self.active_role = match self.primary_reads_enabled {
+                    false => Some(Role::Replica), // If primary should not be receiving reads, use a replica.
+                    true => None,                 // Any server role is fine in this case.
+                }
+            }
+
+            // Likely a write
+            _ => {
+                self.active_role = Some(Role::Primary);
+            }
+        };
+
+        true
+    }
+
+    /// Get the current desired server role we should be talking to.
+    pub fn role(&self) -> Option<Role> {
+        self.active_role
+    }
+
+    /// Get desired shard we should be talking to.
+    pub fn shard(&self) -> usize {
+        match self.active_shard {
+            Some(shard) => shard,
+            None => 0,
+        }
+    }
+
+    /// 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?
+    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::messages::simple_query;
+    use bytes::BufMut;
+
+    #[test]
+    fn test_defaults() {
+        QueryRouter::setup();
+        let qr = QueryRouter::new();
+
+        assert_eq!(qr.role(), None);
+    }
+
+    #[test]
+    fn test_infer_role_replica() {
+        QueryRouter::setup();
+        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);
+        qr.toggle_primary_reads(false);
+
+        let queries = vec![
+            simple_query("SELECT * FROM items WHERE id = 5"),
+            simple_query(
+                "SELECT id, name, value FROM items INNER JOIN prices ON item.id = prices.item_id",
+            ),
+            simple_query("WITH t AS (SELECT * FROM items) SELECT * FROM t"),
+        ];
+
+        for query in queries {
+            // It's a recognized query
+            assert!(qr.infer_role(query));
+            assert_eq!(qr.role(), Some(Role::Replica));
+        }
+    }
+
+    #[test]
+    fn test_infer_role_primary() {
+        QueryRouter::setup();
+        let mut qr = QueryRouter::new();
+
+        let queries = vec![
+            simple_query("UPDATE items SET name = 'pumpkin' WHERE id = 5"),
+            simple_query("INSERT INTO items (id, name) VALUES (5, 'pumpkin')"),
+            simple_query("DELETE FROM items WHERE id = 5"),
+            simple_query("BEGIN"), // Transaction start
+        ];
+
+        for query in queries {
+            // It's a recognized query
+            assert!(qr.infer_role(query));
+            assert_eq!(qr.role(), Some(Role::Primary));
+        }
+    }
+
+    #[test]
+    fn test_infer_role_primary_reads_enabled() {
+        QueryRouter::setup();
+        let mut qr = QueryRouter::new();
+        let query = simple_query("SELECT * FROM items WHERE id = 5");
+        qr.toggle_primary_reads(true);
+
+        assert!(qr.infer_role(query));
+        assert_eq!(qr.role(), None);
+    }
+
+    #[test]
+    fn test_infer_role_parse_prepared() {
+        QueryRouter::setup();
+        let mut qr = QueryRouter::new();
+        qr.try_execute_command(simple_query("SET SERVER ROLE TO 'auto'"));
+        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"[..],
+        );
+        let mut res = BytesMut::from(&b"P"[..]);
+        res.put_i32(prepared_stmt.len() as i32 + 4 + 1 + 2);
+        res.put_u8(0);
+        res.put(prepared_stmt);
+        res.put_i16(0);
+
+        assert!(qr.infer_role(res));
+        assert_eq!(qr.role(), Some(Role::Replica));
+    }
+
+    #[test]
+    fn test_regex_set() {
+        QueryRouter::setup();
+
+        let tests = [
+            // Upper case
+            "SET SHARDING KEY TO '1'",
+            "SET SHARD TO '1'",
+            "SHOW SHARD",
+            "SET SERVER ROLE TO 'replica'",
+            "SET SERVER ROLE TO 'primary'",
+            "SET SERVER ROLE TO 'any'",
+            "SET SERVER ROLE TO 'auto'",
+            "SHOW SERVER ROLE",
+            // Lower case
+            "set sharding key to '1'",
+            "set shard to '1'",
+            "show shard",
+            "set server role to 'replica'",
+            "set server role to 'primary'",
+            "set server role to 'any'",
+            "set server role to 'auto'",
+            "show server role",
+            // No quotes
+            "SET SHARDING KEY TO 11235",
+            "SET SHARD TO 15",
+            // Spaces and semicolon
+            "  SET SHARDING KEY TO 11235  ; ",
+            "  SET SHARD TO 15;   ",
+            "  SET SHARDING KEY TO 11235  ;",
+            " SET SERVER ROLE TO 'primary';   ",
+            "    SET SERVER ROLE TO 'primary'  ; ",
+            "  SET SERVER ROLE TO 'primary'  ;",
+        ];
+
+        // Which regexes it'll match to in the list
+        let matches = [
+            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() {
+            assert!(list[matches[i]].is_match(test));
+            assert_eq!(set.matches(test).into_iter().collect::<Vec<_>>().len(), 1);
+        }
+
+        let bad = [
+            "SELECT * FROM table",
+            "SELECT * FROM table WHERE value = 'set sharding key to 5'", // Don't capture things in the middle of the query
+        ];
+
+        for query in &bad {
+            assert_eq!(set.matches(query).into_iter().collect::<Vec<_>>().len(), 0);
+        }
+    }
+
+    #[test]
+    fn test_try_execute_command() {
+        QueryRouter::setup();
+        let mut qr = QueryRouter::new();
+
+        // SetShardingKey
+        let query = simple_query("SET SHARDING KEY TO 13");
+        assert_eq!(
+            qr.try_execute_command(query),
+            Some((Command::SetShardingKey, String::from("1")))
+        );
+        assert_eq!(qr.shard(), 1);
+
+        // SetShard
+        let query = simple_query("SET SHARD TO '1'");
+        assert_eq!(
+            qr.try_execute_command(query),
+            Some((Command::SetShard, String::from("1")))
+        );
+        assert_eq!(qr.shard(), 1);
+
+        // ShowShard
+        let query = simple_query("SHOW SHARD");
+        assert_eq!(
+            qr.try_execute_command(query),
+            Some((Command::ShowShard, String::from("1")))
+        );
+
+        // SetServerRole
+        let roles = ["primary", "replica", "any", "auto", "primary"];
+        let verify_roles = [
+            Some(Role::Primary),
+            Some(Role::Replica),
+            None,
+            None,
+            Some(Role::Primary),
+        ];
+        let query_parser_enabled = [false, false, false, true, false];
+
+        for (idx, role) in roles.iter().enumerate() {
+            let query = simple_query(&format!("SET SERVER ROLE TO '{}'", role));
+            assert_eq!(
+                qr.try_execute_command(query),
+                Some((Command::SetServerRole, String::from(*role)))
+            );
+            assert_eq!(qr.role(), verify_roles[idx],);
+            assert_eq!(qr.query_parser_enabled(), query_parser_enabled[idx],);
+
+            // ShowServerRole
+            let query = simple_query("SHOW SERVER ROLE");
+            assert_eq!(
+                qr.try_execute_command(query),
+                Some((Command::ShowServerRole, String::from(*role)))
+            );
+        }
+    }
+
+    #[test]
+    fn test_enable_query_parser() {
+        QueryRouter::setup();
+        let mut qr = QueryRouter::new();
+        let query = simple_query("SET SERVER ROLE TO 'auto'");
+        qr.toggle_primary_reads(false);
+
+        assert!(qr.try_execute_command(query) != None);
+        assert!(qr.query_parser_enabled());
+        assert_eq!(qr.role(), None);
+
+        let query = simple_query("INSERT INTO test_table VALUES (1)");
+        assert_eq!(qr.infer_role(query), true);
+        assert_eq!(qr.role(), Some(Role::Primary));
+
+        let query = simple_query("SELECT * FROM test_table");
+        assert_eq!(qr.infer_role(query), true);
+        assert_eq!(qr.role(), Some(Role::Replica));
+
+        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());
+    }
+}
--- a/src/server.rs
+++ b/src/server.rs
@@ -0,0 +1,494 @@
+use bytes::{Buf, BufMut, BytesMut};
+///! 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},
+    TcpStream,
+};
+
+use crate::config::{Address, User};
+use crate::constants::*;
+use crate::errors::Error;
+use crate::messages::*;
+use crate::stats::Reporter;
+use crate::ClientServerMap;
+
+/// Server state.
+pub struct Server {
+    // Server host, e.g. localhost,
+    // port, e.g. 5432, and role, e.g. primary or replica.
+    address: Address,
+
+    // Buffered read socket.
+    read: BufReader<OwnedReadHalf>,
+
+    // Unbuffered write socket (our client code buffers).
+    write: OwnedWriteHalf,
+
+    // 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_info: BytesMut,
+
+    // Backend id and secret key used for query cancellation.
+    process_id: i32,
+    secret_key: i32,
+
+    // Is the server inside a transaction or idle.
+    in_transaction: bool,
+
+    // 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.
+    bad: bool,
+
+    // Mapping of clients and servers used for query cancellation.
+    client_server_map: ClientServerMap,
+
+    // Server connected at.
+    connected_at: chrono::naive::NaiveDateTime,
+
+    // Reports various metrics, e.g. data sent & received.
+    stats: Reporter,
+}
+
+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(
+        address: &Address,
+        user: &User,
+        database: &str,
+        client_server_map: ClientServerMap,
+        stats: Reporter,
+    ) -> Result<Server, Error> {
+        let mut stream =
+            match TcpStream::connect(&format!("{}:{}", &address.host, &address.port)).await {
+                Ok(stream) => stream,
+                Err(err) => {
+                    error!("Could not connect to server: {}", err);
+                    return Err(Error::SocketError);
+                }
+            };
+
+        trace!("Sending StartupMessage");
+
+        // 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;
+        let mut secret_key: i32 = 0;
+
+        // We'll be handling multiple packets, but they will all be structured the same.
+        // We'll loop here until this exchange is complete.
+        loop {
+            let code = match stream.read_u8().await {
+                Ok(code) => code as char,
+                Err(_) => return Err(Error::SocketError),
+            };
+
+            let len = match stream.read_i32().await {
+                Ok(len) => len,
+                Err(_) => return Err(Error::SocketError),
+            };
+
+            trace!("Message: {}", code);
+
+            match code {
+                // Authentication
+                'R' => {
+                    // Determine which kind of authentication is required, if any.
+                    let auth_code = match stream.read_i32().await {
+                        Ok(auth_code) => auth_code,
+                        Err(_) => return Err(Error::SocketError),
+                    };
+
+                    trace!("Auth: {}", auth_code);
+
+                    match auth_code {
+                        MD5_ENCRYPTED_PASSWORD => {
+                            // The salt is 4 bytes.
+                            // See: https://www.postgresql.org/docs/12/protocol-message-formats.html
+                            let mut salt = vec![0u8; 4];
+
+                            match stream.read_exact(&mut salt).await {
+                                Ok(_) => (),
+                                Err(_) => return Err(Error::SocketError),
+                            };
+
+                            md5_password(&mut stream, &user.name, &user.password, &salt[..])
+                                .await?;
+                        }
+
+                        AUTHENTICATION_SUCCESSFUL => (),
+
+                        _ => {
+                            error!("Unsupported authentication mechanism: {}", auth_code);
+                            return Err(Error::ServerError);
+                        }
+                    }
+                }
+
+                // ErrorResponse
+                'E' => {
+                    let error_code = match stream.read_u8().await {
+                        Ok(error_code) => error_code,
+                        Err(_) => return Err(Error::SocketError),
+                    };
+
+                    trace!("Error: {}", error_code);
+
+                    match error_code {
+                        // No error message is present in the message.
+                        MESSAGE_TERMINATOR => (),
+
+                        // An error message will be present.
+                        _ => {
+                            // Read the error message without the terminating null character.
+                            let mut error = vec![0u8; len as usize - 4 - 1];
+
+                            match stream.read_exact(&mut error).await {
+                                Ok(_) => (),
+                                Err(_) => return Err(Error::SocketError),
+                            };
+
+                            // TODO: the error message contains multiple fields; we can decode them and
+                            // present a prettier message to the user.
+                            // See: https://www.postgresql.org/docs/12/protocol-error-fields.html
+                            error!("Server error: {}", String::from_utf8_lossy(&error));
+                        }
+                    };
+
+                    return Err(Error::ServerError);
+                }
+
+                // ParameterStatus
+                'S' => {
+                    let mut param = vec![0u8; len as usize - 4];
+
+                    match stream.read_exact(&mut param).await {
+                        Ok(_) => (),
+                        Err(_) => return Err(Error::SocketError),
+                    };
+
+                    // Save the parameter so we can pass it to the client later.
+                    // These can be server_encoding, client_encoding, server timezone, Postgres version,
+                    // and many more interesting things we should know about the Postgres server we are talking to.
+                    server_info.put_u8(b'S');
+                    server_info.put_i32(len);
+                    server_info.put_slice(&param[..]);
+                }
+
+                // 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
+                    process_id = match stream.read_i32().await {
+                        Ok(id) => id,
+                        Err(_) => return Err(Error::SocketError),
+                    };
+
+                    secret_key = match stream.read_i32().await {
+                        Ok(id) => id,
+                        Err(_) => return Err(Error::SocketError),
+                    };
+                }
+
+                // ReadyForQuery
+                'Z' => {
+                    let mut idle = vec![0u8; len as usize - 4];
+
+                    match stream.read_exact(&mut idle).await {
+                        Ok(_) => (),
+                        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();
+
+                    return Ok(Server {
+                        address: address.clone(),
+                        read: BufReader::new(read),
+                        write: write,
+                        buffer: BytesMut::with_capacity(8196),
+                        server_info: server_info,
+                        process_id: process_id,
+                        secret_key: secret_key,
+                        in_transaction: false,
+                        data_available: false,
+                        bad: false,
+                        client_server_map: client_server_map,
+                        connected_at: chrono::offset::Utc::now().naive_utc(),
+                        stats: stats,
+                    });
+                }
+
+                // We have an unexpected message from the server during this exchange.
+                // Means we implemented the protocol wrong or we're not talking to a Postgres server.
+                _ => {
+                    error!("Unknown code: {}", code);
+                    return Err(Error::ProtocolSyncError);
+                }
+            };
+        }
+    }
+
+    /// Issue a query cancellation request to the server.
+    /// Uses a separate connection that's not part of the connection pool.
+    pub async fn cancel(
+        host: &str,
+        port: &str,
+        process_id: i32,
+        secret_key: i32,
+    ) -> Result<(), Error> {
+        let mut stream = match TcpStream::connect(&format!("{}:{}", host, port)).await {
+            Ok(stream) => stream,
+            Err(err) => {
+                error!("Could not connect to server: {}", err);
+                return Err(Error::SocketError);
+            }
+        };
+
+        debug!("Sending CancelRequest");
+
+        let mut bytes = BytesMut::with_capacity(16);
+        bytes.put_i32(16);
+        bytes.put_i32(CANCEL_REQUEST_CODE);
+        bytes.put_i32(process_id);
+        bytes.put_i32(secret_key);
+
+        Ok(write_all(&mut stream, bytes).await?)
+    }
+
+    /// Send messages to the server from the client.
+    pub async fn send(&mut self, messages: BytesMut) -> Result<(), Error> {
+        self.stats.data_sent(messages.len());
+
+        match write_all_half(&mut self.write, messages).await {
+            Ok(_) => Ok(()),
+            Err(err) => {
+                error!("Terminating server because of: {:?}", err);
+                self.bad = true;
+                Err(err)
+            }
+        }
+    }
+
+    /// Receive data from the server in response to a client request.
+    /// This method must be called multiple times while `self.is_data_available()` is true
+    /// in order to receive all data the server has to offer.
+    pub async fn recv(&mut self) -> Result<BytesMut, Error> {
+        loop {
+            let mut message = match read_message(&mut self.read).await {
+                Ok(message) => message,
+                Err(err) => {
+                    error!("Terminating server because of: {:?}", err);
+                    self.bad = true;
+                    return Err(err);
+                }
+            };
+
+            // Buffer the message we'll forward to the client later.
+            self.buffer.put(&message[..]);
+
+            let code = message.get_u8() as char;
+            let _len = message.get_i32();
+
+            trace!("Message: {}", code);
+
+            match code {
+                // ReadyForQuery
+                'Z' => {
+                    let transaction_state = message.get_u8() as char;
+
+                    match transaction_state {
+                        // In transaction.
+                        'T' => {
+                            self.in_transaction = true;
+                        }
+
+                        // Idle, transaction over.
+                        'I' => {
+                            self.in_transaction = false;
+                        }
+
+                        // Some error occured, the transaction was rolled back.
+                        'E' => {
+                            self.in_transaction = true;
+                        }
+
+                        // Something totally unexpected, this is not a Postgres server we know.
+                        _ => {
+                            self.bad = true;
+                            return Err(Error::ProtocolSyncError);
+                        }
+                    };
+
+                    // There is no more data available from the server.
+                    self.data_available = false;
+
+                    break;
+                }
+
+                // 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 of course.
+                    if self.buffer.len() >= 8196 {
+                        break;
+                    }
+                }
+
+                // CopyInResponse: copy is starting from client to server.
+                'G' => break,
+
+                // CopyOutResponse: copy is starting from the server to the client.
+                'H' => {
+                    self.data_available = true;
+                    break;
+                }
+
+                // CopyData: we are not buffering this one because there will be many more
+                // and we don't know how big this packet could be, best not to take a risk.
+                'd' => break,
+
+                // CopyDone
+                // Buffer until ReadyForQuery shows up, so don't exit the loop yet.
+                'c' => (),
+
+                // Anything else, e.g. errors, notices, etc.
+                // Keep buffering until ReadyForQuery shows up.
+                _ => (),
+            };
+        }
+
+        let bytes = self.buffer.clone();
+
+        // Keep track of how much data we got from the server for stats.
+        self.stats.data_received(bytes.len());
+
+        // Clear the buffer for next query.
+        self.buffer.clear();
+
+        // Pass the data back to the client.
+        Ok(bytes)
+    }
+
+    /// If the server is still inside a transaction.
+    /// If the client disconnects while the server is in a transaction, we will clean it up.
+    pub fn in_transaction(&self) -> bool {
+        self.in_transaction
+    }
+
+    /// We don't buffer all of server responses, e.g. COPY OUT produces too much data.
+    /// The client is responsible to call `self.recv()` while this method returns true.
+    pub fn is_data_available(&self) -> bool {
+        self.data_available
+    }
+
+    /// Server & client are out of sync, we must discard this connection.
+    /// This happens with clients that misbehave.
+    pub fn is_bad(&self) -> bool {
+        self.bad
+    }
+
+    /// Get server startup information to forward it to the client.
+    /// Not used at the moment.
+    pub fn server_info(&self) -> BytesMut {
+        self.server_info.clone()
+    }
+
+    /// Indicate that this server connection cannot be re-used and must be discarded.
+    pub fn mark_bad(&mut self) {
+        error!("Server marked bad");
+        self.bad = true;
+    }
+
+    /// Claim this server as mine for the purposes of query cancellation.
+    pub fn claim(&mut self, process_id: i32, secret_key: i32) {
+        let mut guard = self.client_server_map.lock();
+        guard.insert(
+            (process_id, secret_key),
+            (
+                self.process_id,
+                self.secret_key,
+                self.address.host.clone(),
+                self.address.port.clone(),
+            ),
+        );
+    }
+
+    /// Execute an arbitrary query against the server.
+    /// It will use the simple query protocol.
+    /// Result will not be returned, so this is useful for things like `SET` or `ROLLBACK`.
+    pub async fn query(&mut self, query: &str) -> Result<(), Error> {
+        let query = simple_query(query);
+
+        self.send(query).await?;
+
+        loop {
+            let _ = self.recv().await?;
+
+            if !self.data_available {
+                break;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// A shorthand for `SET application_name = $1`.
+    #[allow(dead_code)]
+    pub async fn set_name(&mut self, name: &str) -> Result<(), Error> {
+        Ok(self
+            .query(&format!("SET application_name = '{}'", name))
+            .await?)
+    }
+
+    /// Get the servers address.
+    #[allow(dead_code)]
+    pub fn address(&self) -> Address {
+        self.address.clone()
+    }
+
+    pub fn process_id(&self) -> i32 {
+        self.process_id
+    }
+}
+
+impl Drop for Server {
+    /// Try to do a clean shut down. Best effort because
+    /// 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.process_id());
+
+        let mut bytes = BytesMut::with_capacity(4);
+        bytes.put_u8(b'X');
+        bytes.put_i32(4);
+
+        match self.write.try_write(&bytes) {
+            Ok(_) => (),
+            Err(_) => (),
+        };
+
+        self.bad = true;
+
+        let now = chrono::offset::Utc::now().naive_utc();
+        let duration = now - self.connected_at;
+
+        info!(
+            "Server connection closed, session duration: {}",
+            crate::format_duration(&duration)
+        );
+    }
+}
--- a/src/sharding.rs
+++ b/src/sharding.rs
@@ -0,0 +1,195 @@
+use sha1::{Digest, Sha1};
+
+// https://github.com/postgres/postgres/blob/27b77ecf9f4d5be211900eda54d8155ada50d696/src/include/catalog/partition.h#L20
+const PARTITION_HASH_SEED: u64 = 0x7A5B22367996DCFD;
+
+#[derive(Debug, PartialEq, Copy, Clone)]
+pub enum ShardingFunction {
+    PgBigintHash,
+    Sha1,
+}
+
+pub struct Sharder {
+    shards: usize,
+    sharding_function: ShardingFunction,
+}
+
+impl Sharder {
+    pub fn new(shards: usize, sharding_function: ShardingFunction) -> Sharder {
+        Sharder {
+            shards,
+            sharding_function,
+        }
+    }
+
+    pub fn shard(&self, key: i64) -> usize {
+        match self.sharding_function {
+            ShardingFunction::PgBigintHash => self.pg_bigint_hash(key),
+            ShardingFunction::Sha1 => self.sha1(key),
+        }
+    }
+
+    /// 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
+    /// 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;
+        let hihalf = (key >> 32) as u32;
+        lohalf ^= if key >= 0 { hihalf } else { !hihalf };
+        Self::combine(0, Self::pg_u32_hash(lohalf)) as usize % self.shards
+    }
+
+    /// Example of a hashing function based on SHA1.
+    fn sha1(&self, key: i64) -> usize {
+        let mut hasher = Sha1::new();
+
+        hasher.update(&key.to_string().as_bytes());
+
+        let result = hasher.finalize();
+
+        // Convert the SHA1 hash into hex so we can parse it as a large integer.
+        let hex = format!("{:x}", result);
+
+        // Parse the last 8 bytes as an integer (8 bytes = bigint).
+        let key = i64::from_str_radix(&hex[hex.len() - 8..], 16).unwrap() as usize;
+
+        key % self.shards
+    }
+
+    #[inline]
+    fn rot(x: u32, k: u32) -> u32 {
+        (x << k) | (x >> (32 - k))
+    }
+
+    #[inline]
+    fn mix(mut a: u32, mut b: u32, mut c: u32) -> (u32, u32, u32) {
+        a = a.wrapping_sub(c);
+        a ^= Self::rot(c, 4);
+        c = c.wrapping_add(b);
+
+        b = b.wrapping_sub(a);
+        b ^= Self::rot(a, 6);
+        a = a.wrapping_add(c);
+
+        c = c.wrapping_sub(b);
+        c ^= Self::rot(b, 8);
+        b = b.wrapping_add(a);
+
+        a = a.wrapping_sub(c);
+        a ^= Self::rot(c, 16);
+        c = c.wrapping_add(b);
+
+        b = b.wrapping_sub(a);
+        b ^= Self::rot(a, 19);
+        a = a.wrapping_add(c);
+
+        c = c.wrapping_sub(b);
+        c ^= Self::rot(b, 4);
+        b = b.wrapping_add(a);
+
+        (a, b, c)
+    }
+
+    #[inline]
+    fn _final(mut a: u32, mut b: u32, mut c: u32) -> (u32, u32, u32) {
+        c ^= b;
+        c = c.wrapping_sub(Self::rot(b, 14));
+        a ^= c;
+        a = a.wrapping_sub(Self::rot(c, 11));
+        b ^= a;
+        b = b.wrapping_sub(Self::rot(a, 25));
+        c ^= b;
+        c = c.wrapping_sub(Self::rot(b, 16));
+        a ^= c;
+        a = a.wrapping_sub(Self::rot(c, 4));
+        b ^= a;
+        b = b.wrapping_sub(Self::rot(a, 14));
+        c ^= b;
+        c = c.wrapping_sub(Self::rot(b, 24));
+        (a, b, c)
+    }
+
+    #[inline]
+    fn combine(mut a: u64, b: u64) -> u64 {
+        a ^= b
+            .wrapping_add(0x49a0f4dd15e5a8e3 as u64)
+            .wrapping_add(a << 54)
+            .wrapping_add(a >> 7);
+        a
+    }
+
+    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;
+        let c = a;
+
+        a = a.wrapping_add((PARTITION_HASH_SEED >> 32) as u32);
+        b = b.wrapping_add(PARTITION_HASH_SEED as u32);
+        let (mut a, b, c) = Self::mix(a, b, c);
+
+        a = a.wrapping_add(k);
+
+        let (_a, b, c) = Self::_final(a, b, c);
+
+        ((b as u64) << 32) | (c as u64)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    // See tests/sharding/partition_hash_test_setup.sql
+    // The output of those SELECT statements will match this test,
+    // confirming that we implemented Postgres BIGINT hashing correctly.
+    #[test]
+    fn test_pg_bigint_hash() {
+        let sharder = Sharder::new(5, ShardingFunction::PgBigintHash);
+
+        let shard_0 = vec![1, 4, 5, 14, 19, 39, 40, 46, 47, 53];
+
+        for v in shard_0 {
+            assert_eq!(sharder.shard(v), 0);
+        }
+
+        let shard_1 = vec![2, 3, 11, 17, 21, 23, 30, 49, 51, 54];
+
+        for v in shard_1 {
+            assert_eq!(sharder.shard(v), 1);
+        }
+
+        let shard_2 = vec![6, 7, 15, 16, 18, 20, 25, 28, 34, 35];
+
+        for v in shard_2 {
+            assert_eq!(sharder.shard(v), 2);
+        }
+
+        let shard_3 = vec![8, 12, 13, 22, 29, 31, 33, 36, 41, 43];
+
+        for v in shard_3 {
+            assert_eq!(sharder.shard(v), 3);
+        }
+
+        let shard_4 = vec![9, 10, 24, 26, 27, 32, 37, 38, 42, 45];
+
+        for v in shard_4 {
+            assert_eq!(sharder.shard(v), 4);
+        }
+    }
+
+    #[test]
+    fn test_sha1_hash() {
+        let sharder = Sharder::new(12, ShardingFunction::Sha1);
+        let ids = vec![
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+        ];
+        let shards = vec![
+            4, 7, 8, 3, 6, 0, 0, 10, 3, 11, 1, 7, 4, 4, 11, 2, 5, 0, 8, 3,
+        ];
+
+        for (i, id) in ids.iter().enumerate() {
+            assert_eq!(sharder.shard(*id), shards[i]);
+        }
+    }
+}
--- a/src/stats.rs
+++ b/src/stats.rs
@@ -0,0 +1,422 @@
+use log::{debug, info};
+use once_cell::sync::Lazy;
+use parking_lot::Mutex;
+use statsd::Client;
+use tokio::sync::mpsc::{Receiver, Sender};
+
+use std::collections::HashMap;
+
+use crate::config::get_config;
+
+// Stats used in SHOW STATS
+static LATEST_STATS: Lazy<Mutex<HashMap<String, i64>>> = Lazy::new(|| Mutex::new(HashMap::new()));
+static STAT_PERIOD: u64 = 15000; //15 seconds
+
+#[derive(Debug, Clone, Copy)]
+enum EventName {
+    CheckoutTime,
+    Query,
+    Transaction,
+    DataSent,
+    DataReceived,
+    ClientWaiting,
+    ClientActive,
+    ClientIdle,
+    ClientDisconnecting,
+    ServerActive,
+    ServerIdle,
+    ServerTested,
+    ServerLogin,
+    ServerDisconnecting,
+    FlushStatsToStatsD,
+}
+
+#[derive(Debug)]
+pub struct Event {
+    name: EventName,
+    value: i64,
+    process_id: Option<i32>,
+}
+
+#[derive(Clone, Debug)]
+pub struct Reporter {
+    tx: Sender<Event>,
+}
+
+impl Reporter {
+    pub fn new(tx: Sender<Event>) -> Reporter {
+        Reporter { tx: tx }
+    }
+
+    pub fn query(&self) {
+        let event = Event {
+            name: EventName::Query,
+            value: 1,
+            process_id: None,
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn transaction(&self) {
+        let event = Event {
+            name: EventName::Transaction,
+            value: 1,
+            process_id: None,
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn data_sent(&self, amount: usize) {
+        let event = Event {
+            name: EventName::DataSent,
+            value: amount as i64,
+            process_id: None,
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn data_received(&self, amount: usize) {
+        let event = Event {
+            name: EventName::DataReceived,
+            value: amount as i64,
+            process_id: None,
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn checkout_time(&self, ms: u128) {
+        let event = Event {
+            name: EventName::CheckoutTime,
+            value: ms as i64,
+            process_id: None,
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn client_waiting(&self, process_id: i32) {
+        let event = Event {
+            name: EventName::ClientWaiting,
+            value: 1,
+            process_id: Some(process_id),
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn client_active(&self, process_id: i32) {
+        let event = Event {
+            name: EventName::ClientActive,
+            value: 1,
+            process_id: Some(process_id),
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn client_idle(&self, process_id: i32) {
+        let event = Event {
+            name: EventName::ClientIdle,
+            value: 1,
+            process_id: Some(process_id),
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn client_disconnecting(&self, process_id: i32) {
+        let event = Event {
+            name: EventName::ClientDisconnecting,
+            value: 1,
+            process_id: Some(process_id),
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn server_active(&self, process_id: i32) {
+        let event = Event {
+            name: EventName::ServerActive,
+            value: 1,
+            process_id: Some(process_id),
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn server_idle(&self, process_id: i32) {
+        let event = Event {
+            name: EventName::ServerIdle,
+            value: 1,
+            process_id: Some(process_id),
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn server_login(&self, process_id: i32) {
+        let event = Event {
+            name: EventName::ServerLogin,
+            value: 1,
+            process_id: Some(process_id),
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn server_tested(&self, process_id: i32) {
+        let event = Event {
+            name: EventName::ServerTested,
+            value: 1,
+            process_id: Some(process_id),
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+
+    pub fn server_disconnecting(&self, process_id: i32) {
+        let event = Event {
+            name: EventName::ServerDisconnecting,
+            value: 1,
+            process_id: Some(process_id),
+        };
+
+        let _ = self.tx.try_send(event);
+    }
+}
+
+pub struct Collector {
+    rx: Receiver<Event>,
+    tx: Sender<Event>,
+    client: Client,
+}
+
+impl Collector {
+    pub fn new(rx: Receiver<Event>, tx: Sender<Event>) -> Collector {
+        Collector {
+            rx,
+            tx,
+            client: Client::new(&get_config().general.statsd_address, "pgcat").unwrap(),
+        }
+    }
+
+    pub async fn collect(&mut self) {
+        info!("Events reporter started");
+
+        let mut stats = HashMap::from([
+            ("total_query_count", 0),
+            ("total_xact_count", 0),
+            ("total_sent", 0),
+            ("total_received", 0),
+            ("total_xact_time", 0),
+            ("total_query_time", 0),
+            ("total_wait_time", 0),
+            ("avg_xact_time", 0),
+            ("avg_query_time", 0),
+            ("avg_xact_count", 0),
+            ("avg_sent", 0),
+            ("avg_received", 0),
+            ("avg_wait_time", 0),
+            ("maxwait_us", 0),
+            ("maxwait", 0),
+            ("cl_waiting", 0),
+            ("cl_active", 0),
+            ("cl_idle", 0),
+            ("sv_idle", 0),
+            ("sv_active", 0),
+            ("sv_login", 0),
+            ("sv_tested", 0),
+        ]);
+
+        // Stats saved after each iteration of the flush event. Used in calculation
+        // of averages in the last flush period.
+        let mut old_stats: HashMap<String, i64> = HashMap::new();
+
+        // Track which state the client and server are at any given time.
+        let mut client_server_states: HashMap<i32, EventName> = HashMap::new();
+
+        // Flush stats to StatsD and calculate averages every 15 seconds.
+        let tx = self.tx.clone();
+        tokio::task::spawn(async move {
+            let mut interval =
+                tokio::time::interval(tokio::time::Duration::from_millis(STAT_PERIOD));
+            loop {
+                interval.tick().await;
+                let _ = tx.try_send(Event {
+                    name: EventName::FlushStatsToStatsD,
+                    value: 0,
+                    process_id: None,
+                });
+            }
+        });
+
+        // The collector loop
+        loop {
+            let stat = match self.rx.recv().await {
+                Some(stat) => stat,
+                None => {
+                    info!("Events collector is shutting down");
+                    return;
+                }
+            };
+
+            // Some are counters, some are gauges...
+            match stat.name {
+                EventName::Query => {
+                    let counter = stats.entry("total_query_count").or_insert(0);
+                    *counter += stat.value;
+                }
+
+                EventName::Transaction => {
+                    let counter = stats.entry("total_xact_count").or_insert(0);
+                    *counter += stat.value;
+                }
+
+                EventName::DataSent => {
+                    let counter = stats.entry("total_sent").or_insert(0);
+                    *counter += stat.value;
+                }
+
+                EventName::DataReceived => {
+                    let counter = stats.entry("total_received").or_insert(0);
+                    *counter += stat.value;
+                }
+
+                EventName::CheckoutTime => {
+                    let counter = stats.entry("total_wait_time").or_insert(0);
+                    *counter += stat.value;
+
+                    let counter = stats.entry("maxwait_us").or_insert(0);
+                    let mic_part = stat.value % 1_000_000;
+
+                    // Report max time here
+                    if mic_part > *counter {
+                        *counter = mic_part;
+                    }
+
+                    let counter = stats.entry("maxwait").or_insert(0);
+                    let seconds = *counter / 1_000_000;
+
+                    if seconds > *counter {
+                        *counter = seconds;
+                    }
+                }
+
+                EventName::ClientActive
+                | EventName::ClientWaiting
+                | EventName::ClientIdle
+                | EventName::ServerActive
+                | EventName::ServerIdle
+                | EventName::ServerTested
+                | EventName::ServerLogin => {
+                    client_server_states.insert(stat.process_id.unwrap(), stat.name);
+                }
+
+                EventName::ClientDisconnecting | EventName::ServerDisconnecting => {
+                    client_server_states.remove(&stat.process_id.unwrap());
+                }
+
+                EventName::FlushStatsToStatsD => {
+                    // Calculate connection states
+                    for (_, state) in &client_server_states {
+                        match state {
+                            EventName::ClientActive => {
+                                let counter = stats.entry("cl_active").or_insert(0);
+                                *counter += 1;
+                            }
+
+                            EventName::ClientWaiting => {
+                                let counter = stats.entry("cl_waiting").or_insert(0);
+                                *counter += 1;
+                            }
+
+                            EventName::ClientIdle => {
+                                let counter = stats.entry("cl_idle").or_insert(0);
+                                *counter += 1;
+                            }
+
+                            EventName::ServerIdle => {
+                                let counter = stats.entry("sv_idle").or_insert(0);
+                                *counter += 1;
+                            }
+
+                            EventName::ServerActive => {
+                                let counter = stats.entry("sv_active").or_insert(0);
+                                *counter += 1;
+                            }
+
+                            EventName::ServerTested => {
+                                let counter = stats.entry("sv_tested").or_insert(0);
+                                *counter += 1;
+                            }
+
+                            EventName::ServerLogin => {
+                                let counter = stats.entry("sv_login").or_insert(0);
+                                *counter += 1;
+                            }
+
+                            _ => unreachable!(),
+                        };
+                    }
+
+                    // Calculate averages
+                    for stat in &[
+                        "avg_query_count",
+                        "avgxact_count",
+                        "avg_sent",
+                        "avg_received",
+                        "avg_wait_time",
+                    ] {
+                        let total_name = stat.replace("avg_", "total_");
+                        let old_value = old_stats.entry(total_name.clone()).or_insert(0);
+                        let new_value = stats.get(total_name.as_str()).unwrap_or(&0).to_owned();
+                        let avg = (new_value - *old_value) / (STAT_PERIOD as i64 / 1_000); // Avg / second
+
+                        stats.insert(stat, avg);
+                        *old_value = new_value;
+                    }
+
+                    debug!("{:?}", stats);
+
+                    // Update latest stats used in SHOW STATS
+                    let mut guard = LATEST_STATS.lock();
+                    for (key, value) in &stats {
+                        guard.insert(key.to_string(), value.clone());
+                    }
+
+                    let mut pipeline = self.client.pipeline();
+
+                    for (key, value) in stats.iter() {
+                        pipeline.gauge(key, *value as f64);
+                    }
+
+                    // These are re-calculated every iteration of the loop, so we don't want to add values
+                    // from the last iteration.
+                    for stat in &[
+                        "cl_active",
+                        "cl_waiting",
+                        "cl_idle",
+                        "sv_idle",
+                        "sv_active",
+                        "sv_tested",
+                        "sv_login",
+                        "maxwait",
+                        "maxwait_us",
+                    ] {
+                        stats.insert(stat, 0);
+                    }
+
+                    pipeline.send(&self.client);
+                }
+            };
+        }
+    }
+}
+
+pub fn get_stats() -> HashMap<String, i64> {
+    LATEST_STATS.lock().clone()
+}
--- 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/python/.gitignore
+++ b/tests/python/.gitignore
@@ -0,0 +1 @@
+venv/
--- a/tests/python/requirements.txt
+++ b/tests/python/requirements.txt
@@ -0,0 +1 @@
+psycopg2==2.9.3
--- a/tests/python/tests.py
+++ b/tests/python/tests.py
@@ -0,0 +1,11 @@
+import psycopg2
+
+conn = psycopg2.connect("postgres://random:password@127.0.0.1:6432/db")
+cur = conn.cursor()
+
+cur.execute("SELECT 1");
+res = cur.fetchall()
+
+print(res)
+
+# conn.commit()
--- a/tests/ruby/.ruby-version
+++ b/tests/ruby/.ruby-version
@@ -0,0 +1 @@
+2.7.1
--- a/tests/ruby/Gemfile
+++ b/tests/ruby/Gemfile
@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem "pg"
+gem "activerecord"
--- a/tests/ruby/Gemfile.lock
+++ b/tests/ruby/Gemfile.lock
@@ -0,0 +1,30 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    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)
+    concurrent-ruby (1.1.9)
+    i18n (1.10.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.15.0)
+    pg (1.3.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  activerecord
+  pg
+
+BUNDLED WITH
+   2.3.7
--- a/tests/ruby/tests.rb
+++ b/tests/ruby/tests.rb
@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+# Uncomment these two to see all queries.
+# ActiveRecord.verbose_query_logs = true
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+ActiveRecord::Base.establish_connection(
+  adapter: 'postgresql',
+  host: '127.0.0.1',
+  port: 6432,
+  username: 'sharding_user',
+  password: 'sharding_user',
+  database: 'rails_dev',
+  prepared_statements: false, # Transaction mode
+  advisory_locks: false # Same
+)
+
+class TestSafeTable < ActiveRecord::Base
+  self.table_name = 'test_safe_table'
+end
+
+class ShouldNeverHappenException < RuntimeError
+end
+
+class CreateSafeShardedTable < ActiveRecord::Migration[7.0]
+  # Disable transasctions or things will fly out of order!
+  disable_ddl_transaction!
+
+  SHARDS = 3
+
+  def up
+    SHARDS.times do |x|
+      # This will make this migration reversible!
+      connection.execute "SET SHARD TO '#{x.to_i}'"
+      connection.execute "SET SERVER ROLE TO 'primary'"
+
+      connection.execute <<-SQL
+        CREATE TABLE test_safe_table (
+          id BIGINT PRIMARY KEY,
+          name VARCHAR,
+          description TEXT
+        ) PARTITION BY HASH (id);
+
+        CREATE TABLE test_safe_table_data PARTITION OF test_safe_table
+        FOR VALUES WITH (MODULUS #{SHARDS.to_i}, REMAINDER #{x.to_i});
+      SQL
+    end
+  end
+
+  def down
+    SHARDS.times do |x|
+      connection.execute "SET SHARD TO '#{x.to_i}'"
+      connection.execute "SET SERVER ROLE TO 'primary'"
+      connection.execute 'DROP TABLE test_safe_table CASCADE'
+    end
+  end
+end
+
+SHARDS = 3
+
+2.times do
+  begin
+    CreateSafeShardedTable.migrate(:down)
+  rescue Exception
+    puts "Tables don't exist yet"
+  end
+
+  CreateSafeShardedTable.migrate(:up)
+
+  SHARDS.times do |x|
+    TestSafeTable.connection.execute "SET SHARD TO '#{x.to_i}'"
+    TestSafeTable.connection.execute "SET SERVER ROLE TO 'primary'"
+    TestSafeTable.connection.execute "TRUNCATE #{TestSafeTable.table_name}"
+  end
+
+  # Equivalent to Makara's stick_to_master! except it sticks until it's changed.
+  TestSafeTable.connection.execute "SET SERVER ROLE TO 'primary'"
+
+  200.times do |x|
+    x += 1 # Postgres ids start at 1
+    TestSafeTable.connection.execute "SET SHARDING KEY TO '#{x.to_i}'"
+    TestSafeTable.create(id: x, name: "something_special_#{x.to_i}", description: "It's a surprise!")
+  end
+
+  TestSafeTable.connection.execute "SET SERVER ROLE TO 'replica'"
+
+  100.times do |x|
+    x += 1 # 0 confuses our sharding function
+    TestSafeTable.connection.execute "SET SHARDING KEY TO '#{x.to_i}'"
+    TestSafeTable.find_by_id(x).id
+  end
+
+  # Will use the query parser to direct reads to replicas
+  TestSafeTable.connection.execute "SET SERVER ROLE TO 'auto'"
+
+  100.times do |x|
+    x += 101
+    TestSafeTable.connection.execute "SET SHARDING KEY TO '#{x.to_i}'"
+    TestSafeTable.find_by_id(x).id
+  end
+end
+
+# Test wrong shard
+TestSafeTable.connection.execute "SET SHARD TO '1'"
+begin
+  TestSafeTable.create(id: 5, name: 'test', description: 'test description')
+  raise ShouldNeverHappenException('Uh oh')
+rescue ActiveRecord::StatementInvalid
+  puts 'OK'
+end
--- a/tests/sharding/README.md
+++ b/tests/sharding/README.md
@@ -0,0 +1,35 @@
+# Sharding tests
+
+This helps us test the sharding algorithm we implemented.
+
+
+## Setup
+
+We setup 3 Postgres DBs, `shard0`, `shard1`, and `shard2`. In each database, we create a partitioned table called `data`. The table is partitioned by hash, and each database will only have _one_ partition, `shard0` will satisfy `modulus 3, remainder 0`, `shard1` will satisfy `modulus 3, remainder 1`, etc.
+
+To set this up, you can just run:
+
+```bash
+psql -f query_routing_setup.sql
+```
+
+## Run the tests
+
+Start up PgCat by running `cargo run --release` in the root of the repo. In a different tab, run this:
+
+```bash
+psql -h 127.0.0.1 -p 6432 -f query_routing_test_insert.sql
+psql -h 127.0.0.1 -p 6432 -f query_routing_test_select.sql
+```
+
+Note that no errors should take place. If our sharding logic was incorrect, we would get some errors
+about unsatisfiable partition bounds. We don't because the pooler picked the correct databases
+given the sharding keys.
+
+Finally, you can validate the result again by running
+
+```bash
+psql -f query_routing_test_validate.sql
+```
+
+## That's it!
--- a/tests/sharding/partition_hash_test_setup.sql
+++ b/tests/sharding/partition_hash_test_setup.sql
@@ -0,0 +1,26 @@
+DROP TABLE IF EXISTS shards CASCADE;
+
+CREATE TABLE shards (
+    id BIGINT,
+    value VARCHAR
+) PARTITION BY HASH (id);
+
+-- DROP TABLE IF EXISTS shard_0;
+CREATE TABLE shard_0 PARTITION OF shards FOR VALUES WITH (MODULUS 5, REMAINDER 0);
+-- DROP TABLE IF EXISTS shard_1;
+CREATE TABLE shard_1 PARTITION OF shards FOR VALUES WITH (MODULUS 5, REMAINDER 1);
+-- DROP TABLE IF EXISTS shard_2;
+CREATE TABLE shard_2 PARTITION OF shards FOR VALUES WITH (MODULUS 5, REMAINDER 2);
+-- DROP TABLE IF EXISTS shard_3;
+CREATE TABLE shard_3 PARTITION OF shards FOR VALUES WITH (MODULUS 5, REMAINDER 3);
+-- DROP TABLE IF EXISTS shard_4;
+CREATE TABLE shard_4 PARTITION OF shards FOR VALUES WITH (MODULUS 5, REMAINDER 4);
+
+
+INSERT INTO shards SELECT generate_series(1, 500), 'value';
+
+SELECT * FROM shard_0 ORDER BY id LIMIT 10;
+SELECT * FROM shard_1 ORDER BY id LIMIT 10;
+SELECT * FROM shard_2 ORDER BY id LIMIT 10;
+SELECT * FROM shard_3 ORDER BY id LIMIT 10;
+SELECT * FROM shard_4 ORDER BY id LIMIT 10;
--- a/tests/sharding/query_routing.sh
+++ b/tests/sharding/query_routing.sh
@@ -0,0 +1,19 @@
+#/bin/bash
+set -e
+
+# Setup all the shards.
+# sudo service postgresql restart
+
+echo "Giving Postgres 5 seconds to start up..."
+
+# sleep 5
+
+# psql -f query_routing_setup.sql
+
+psql -h 127.0.0.1 -p 6432 -f query_routing_test_insert.sql
+
+psql -h 127.0.0.1 -p 6432 -f query_routing_test_select.sql
+
+psql -e -h 127.0.0.1 -p 6432 -f query_routing_test_primary_replica.sql
+
+psql -f query_routing_test_validate.sql
--- a/tests/sharding/query_routing_setup.sql
+++ b/tests/sharding/query_routing_setup.sql
@@ -0,0 +1,61 @@
+
+DROP DATABASE IF EXISTS shard0;
+DROP DATABASE IF EXISTS shard1;
+DROP DATABASE IF EXISTS shard2;
+
+CREATE DATABASE shard0;
+CREATE DATABASE shard1;
+CREATE DATABASE shard2;
+
+\c shard0
+
+DROP TABLE IF EXISTS data CASCADE;
+
+CREATE TABLE data (
+    id BIGINT,
+    value VARCHAR
+) PARTITION BY HASH (id);
+
+CREATE TABLE data_shard_0 PARTITION OF data FOR VALUES WITH (MODULUS 3, REMAINDER 0);
+
+\c shard1
+
+DROP TABLE IF EXISTS data CASCADE;
+
+CREATE TABLE data (
+    id BIGINT,
+    value VARCHAR
+) PARTITION BY HASH (id);
+
+CREATE TABLE data_shard_1 PARTITION OF data FOR VALUES WITH (MODULUS 3, REMAINDER 1);
+
+
+\c shard2
+
+DROP TABLE IF EXISTS data CASCADE;
+
+CREATE TABLE data (
+    id BIGINT,
+    value VARCHAR
+) PARTITION BY HASH (id);
+
+CREATE TABLE data_shard_2 PARTITION OF data FOR VALUES WITH (MODULUS 3, REMAINDER 2);
+
+DROP ROLE IF EXISTS sharding_user;
+CREATE ROLE sharding_user ENCRYPTED PASSWORD 'sharding_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;
+
+\c shard0
+GRANT ALL ON SCHEMA public TO sharding_user;
+GRANT ALL ON TABLE data TO sharding_user;
+
+\c shard1
+GRANT ALL ON SCHEMA public TO sharding_user;
+GRANT ALL ON TABLE data TO sharding_user;
+
+\c shard2
+GRANT ALL ON SCHEMA public TO sharding_user;
+GRANT ALL ON TABLE data TO sharding_user;
--- a/tests/sharding/query_routing_test_insert.sql
+++ b/tests/sharding/query_routing_test_insert.sql
@@ -0,0 +1,55 @@
+\set ON_ERROR_STOP on
+
+SET SHARDING KEY TO '1';
+INSERT INTO data (id, value) VALUES (1, 'value_1');
+
+SET SHARDING KEY TO '2';
+INSERT INTO data (id, value) VALUES (2, 'value_1');
+
+SET SHARDING KEY TO '3';
+INSERT INTO data (id, value) VALUES (3, 'value_1');
+
+SET SHARDING KEY TO '4';
+INSERT INTO data (id, value) VALUES (4, 'value_1');
+
+SET SHARDING KEY TO '5';
+INSERT INTO data (id, value) VALUES (5, 'value_1');
+
+SET SHARDING KEY TO '6';
+INSERT INTO data (id, value) VALUES (6, 'value_1');
+
+SET SHARDING KEY TO '7';
+INSERT INTO data (id, value) VALUES (7, 'value_1');
+
+SET SHARDING KEY TO '8';
+INSERT INTO data (id, value) VALUES (8, 'value_1');
+
+SET SHARDING KEY TO '9';
+INSERT INTO data (id, value) VALUES (9, 'value_1');
+
+SET SHARDING KEY TO '10';
+INSERT INTO data (id, value) VALUES (10, 'value_1');
+
+SET SHARDING KEY TO '11';
+INSERT INTO data (id, value) VALUES (11, 'value_1');
+
+SET SHARDING KEY TO '12';
+INSERT INTO data (id, value) VALUES (12, 'value_1');
+
+SET SHARDING KEY TO '13';
+INSERT INTO data (id, value) VALUES (13, 'value_1');
+
+SET SHARDING KEY TO '14';
+INSERT INTO data (id, value) VALUES (14, 'value_1');
+
+SET SHARDING KEY TO '15';
+INSERT INTO data (id, value) VALUES (15, 'value_1');
+
+SET SHARDING KEY TO '16';
+INSERT INTO data (id, value) VALUES (16, 'value_1');
+
+set sharding key to '17';
+INSERT INTO data (id, value) VALUES (17, 'value_1');
+
+SeT SHaRDInG KeY to '18';
+INSERT INTO data (id, value) VALUES (18, 'value_1');
--- a/tests/sharding/query_routing_test_primary_replica.sql
+++ b/tests/sharding/query_routing_test_primary_replica.sql
@@ -0,0 +1,153 @@
+\set ON_ERROR_STOP on
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '1';
+INSERT INTO data (id, value) VALUES (1, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '1';
+SELECT * FROM data WHERE id = 1;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '2';
+INSERT INTO data (id, value) VALUES (2, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '2';
+SELECT * FROM data WHERE id = 2;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '3';
+INSERT INTO data (id, value) VALUES (3, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '3';
+SELECT * FROM data WHERE id = 3;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '4';
+INSERT INTO data (id, value) VALUES (4, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '4';
+SELECT * FROM data WHERE id = 4;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '5';
+INSERT INTO data (id, value) VALUES (5, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '5';
+SELECT * FROM data WHERE id = 5;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '6';
+INSERT INTO data (id, value) VALUES (6, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '6';
+SELECT * FROM data WHERE id = 6;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '7';
+INSERT INTO data (id, value) VALUES (7, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '7';
+SELECT * FROM data WHERE id = 7;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '8';
+INSERT INTO data (id, value) VALUES (8, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '8';
+SELECT * FROM data WHERE id = 8;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '9';
+INSERT INTO data (id, value) VALUES (9, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '9';
+SELECT * FROM data WHERE id = 9;
+
+---
+
+\set ON_ERROR_STOP on
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '10';
+INSERT INTO data (id, value) VALUES (10, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '10';
+SELECT * FROM data WHERE id = 10;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '11';
+INSERT INTO data (id, value) VALUES (11, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '11';
+SELECT * FROM data WHERE id = 11;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '12';
+INSERT INTO data (id, value) VALUES (12, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '12';
+SELECT * FROM data WHERE id = 12;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '13';
+INSERT INTO data (id, value) VALUES (13, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '13';
+SELECT * FROM data WHERE id = 13;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SET SHARDING KEY TO '14';
+INSERT INTO data (id, value) VALUES (14, 'value_1');
+
+SET SERVER ROLE TO 'replica';
+SET SHARDING KEY TO '14';
+SELECT * FROM data WHERE id = 14;
+
+---
+
+SET SERVER ROLE TO 'primary';
+SELECT 1;
+
+SET SERVER ROLE TO 'replica';
+SELECT 1;
+
+set server role to 'replica';
+SeT SeRver Role TO 'PrImARY';
+select 1;
--- a/tests/sharding/query_routing_test_select.sql
+++ b/tests/sharding/query_routing_test_select.sql
@@ -0,0 +1,49 @@
+\set ON_ERROR_STOP on
+
+SET SHARDING KEY TO '1';
+SELECT * FROM data WHERE id = 1;
+
+SET SHARDING KEY TO '2';
+SELECT * FROM data WHERE id = 2;
+
+SET SHARDING KEY TO '3';
+SELECT * FROM data WHERE id = 3;
+
+SET SHARDING KEY TO '4';
+SELECT * FROM data WHERE id = 4;
+
+SET SHARDING KEY TO '5';
+SELECT * FROM data WHERE id = 5;
+
+SET SHARDING KEY TO '6';
+SELECT * FROM data WHERE id = 6;
+
+SET SHARDING KEY TO '7';
+SELECT * FROM data WHERE id = 7;
+
+SET SHARDING KEY TO '8';
+SELECT * FROM data WHERE id = 8;
+
+SET SHARDING KEY TO '9';
+SELECT * FROM data WHERE id = 9;
+
+SET SHARDING KEY TO '10';
+SELECT * FROM data WHERE id = 10;
+
+SET SHARDING KEY TO '11';
+SELECT * FROM data WHERE id = 11;
+
+SET SHARDING KEY TO '12';
+SELECT * FROM data WHERE id = 12;
+
+SET SHARDING KEY TO '13';
+SELECT * FROM data WHERE id = 13;
+
+SET SHARDING KEY TO '14';
+SELECT * FROM data WHERE id = 14;
+
+SET SHARDING KEY TO '15';
+SELECT * FROM data WHERE id = 15;
+
+SET SHARDING KEY TO '16';
+SELECT * FROM data WHERE id = 16;
--- a/tests/sharding/query_routing_test_validate.sql
+++ b/tests/sharding/query_routing_test_validate.sql
@@ -0,0 +1,11 @@
+\c shard0
+
+SELECT * FROM data;
+
+\c shard1
+
+SELECT * FROM data;
+
+\c shard2
+
+SELECT * FROM data;