Feat/unix sockets

integration/unix_sockets/pgdog.toml

@@ -0,0 +1,15 @@
+# ------------------------------------------------------------------------------
+# ----- General ----------------------------------------------------------------
+
+[general]
+auth_type = "trust"
+
+# ------------------------------------------------------------------------------
+# ----- Database :: pgdog ------------------------------------------------------
+
+[[databases]]
+name = "pgdog"
+host = "/tmp"
+port = 5432
+database_name = "pgdog"
+user = "pgdog"

integration/unix_sockets/run.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# End-to-end test: pgdog connecting to Postgres over a Unix domain socket.
+set -euo pipefail
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+source ${SCRIPT_DIR}/../common.sh
+
+export PGPASSWORD=pgdog
+CTL_PSQL=(psql -h 127.0.0.1 -p 5432 -U pgdog -d postgres -t -A)
+
+# Detect socket dir + port from the running Postgres.
+SOCKET_DIR=$("${CTL_PSQL[@]}" -c "show unix_socket_directories" | cut -d, -f1)
+PG_BACKEND_PORT=$("${CTL_PSQL[@]}" -c "show port")
+if [ -z "${SOCKET_DIR}" ]; then
+    echo "FAIL: could not detect unix_socket_directories from Postgres" >&2
+    exit 1
+fi
+echo "Postgres unix socket directory: ${SOCKET_DIR} (port ${PG_BACKEND_PORT})"
+
+# Pre-flight: pgdog must be able to reach Postgres over the socket as pgdog.
+if ! psql -h "${SOCKET_DIR}" -p "${PG_BACKEND_PORT}" -U pgdog -d postgres \
+    -c "select 1" >/dev/null 2>&1; then
+    echo "FAIL: cannot connect to Postgres over unix socket ${SOCKET_DIR} as pgdog." >&2
+    echo "      Check pg_hba.conf 'local' lines: trust, or peer with OS user pgdog." >&2
+    exit 1
+fi
+
+# Patch the static config with the detected socket dir/port into a temp dir.
+TMP_CFG_DIR=$(mktemp -d /tmp/pgdog-unix-cfg.XXXXXX)
+sed -e "s|^host = .*|host = \"${SOCKET_DIR}\"|" \
+    -e "s|^port = .*|port = ${PG_BACKEND_PORT}|" \
+    "${SCRIPT_DIR}/pgdog.toml" > "${TMP_CFG_DIR}/pgdog.toml"
+cp "${SCRIPT_DIR}/users.toml" "${TMP_CFG_DIR}/"
+
+run_pgdog "${TMP_CFG_DIR}"
+wait_for_pgdog
+
+# 1. Query through the proxy.
+psql -h 127.0.0.1 -p 6432 -U pgdog -d pgdog -v ON_ERROR_STOP=1 \
+    -c "select version()" >/dev/null
+echo "PASS: query through pgdog"
+
+# 2. Backend connections over the Unix socket have client_addr IS NULL.
+CONNS=$("${CTL_PSQL[@]}" -c \
+    "select count(*) from pg_stat_activity where usename = 'pgdog' and backend_type = 'client backend' and client_addr is null")
+if [ -z "${CONNS}" ] || [ "${CONNS}" = "0" ]; then
+    echo "FAIL: no backend connections over Unix socket (client_addr IS NULL)" >&2
+    exit 1
+fi
+echo "PASS: ${CONNS} backend connection(s) over Unix socket"
+
+stop_pgdog
+rm -rf "${TMP_CFG_DIR}"

integration/unix_sockets/users.toml

@@ -0,0 +1,4 @@
+[[users]]
+name = "pgdog"
+database = "pgdog"
+password = "pgdog"

pgdog/src/admin/show_bans.rs

@@ -55,7 +55,7 @@ impl Command for ShowBans {
                     row.add(pool.id() as i64)
                         .add(user.database.as_str())
                         .add(user.user.as_str())
-                        .add(pool.addr().host.as_str())
+                        .add(pool.addr().host.to_string())
                         .add(pool.addr().port as i64)
                         .add(shard_num as i64)
                         .add(role.to_string())

pgdog/src/admin/show_pools.rs

@@ -58,7 +58,7 @@ impl Command for ShowPools {
                     row.add(pool.id() as i64)
                         .add(user.database.as_str())
                         .add(user.user.as_str())
-                        .add(pool.addr().host.as_str())
+                        .add(pool.addr().host.to_string())
                         .add(pool.addr().port as i64)
                         .add(shard_num as i64)
                         .add(role.to_string())

pgdog/src/admin/show_replication.rs

@@ -53,7 +53,7 @@ impl Command for ShowReplication {
                     row.add(pool.id() as i64)
                         .add(user.database.as_str())
                         .add(user.user.as_str())
-                        .add(pool.addr().host.as_str())
+                        .add(pool.addr().host.to_string())
                         .add(pool.addr().port as i64)
                         .add(shard_num as i64)
                         .add(role.to_string())

pgdog/src/admin/show_server_memory.rs

@@ -43,7 +43,7 @@ impl Command for ShowServerMemory {
             row.add(server.stats.pool_id as i64)
                 .add(server.addr.database_name.as_str())
                 .add(server.addr.user.as_str())
-                .add(server.addr.host.as_str())
+                .add(server.addr.host.to_string())
                 .add(server.addr.port as i64)
                 .add(server.stats.id)
                 .add(memory.buffer.reallocs as i64)

pgdog/src/admin/show_servers.rs

@@ -90,7 +90,7 @@ impl Command for ShowServers {
                 .add("pool_id", server.stats.pool_id)
                 .add("database", server.addr.database_name)
                 .add("user", server.addr.user)
-                .add("addr", server.addr.host.as_str())
+                .add("addr", server.addr.host.to_string())
                 .add("port", server.addr.port.to_string())
                 .add("state", server.stats.state.to_string())
                 .add(

pgdog/src/admin/show_stats.rs

@@ -78,7 +78,7 @@ impl Command for ShowStats {
 
                     dr.add(user.database.as_str())
                         .add(user.user.as_str())
-                        .add(&pool.addr().host)
+                        .add(pool.addr().host.to_string())
                         .add(pool.addr().port as i64)
                         .add(shard_num)
                         .add(role.to_string());

pgdog/src/backend/auth/azure_workload_identity.rs

@@ -40,6 +40,7 @@ mod tests {
     use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
 
     use super::*;
+    use crate::backend::pool::transport::Transport;
     use crate::config::ServerAuth;
     use crate::test_utils::set_env_var;
     use pgdog_config::Role;

pgdog/src/backend/auth/rds_iam.rs

@@ -37,7 +37,8 @@ fn resolve_region(addr: &Address) -> Result<String, Error> {
         return Ok(region.clone());
     }
 
-    infer_region_from_rds_host(&addr.host).ok_or_else(|| {
+    let host = addr.host.tcp()?;
+    infer_region_from_rds_host(host).ok_or_else(|| {
         Error::RdsIamToken(format!(
             "unable to infer AWS region from host \"{}\"; set \"server_iam_region\"",
             addr.host
@@ -53,9 +54,10 @@ fn resolve_region(addr: &Address) -> Result<String, Error> {
 pub(crate) async fn token(addr: Address) -> Result<(String, SystemTime), Error> {
     let region = resolve_region(&addr)?;
     let sdk_config = aws_config::load_defaults(BehaviorVersion::latest()).await;
+    let host = addr.host.tcp()?;
 
     let config = AuthTokenConfig::builder()
-        .hostname(addr.host.as_str())
+        .hostname(host)
         .port(addr.port.into())
         .username(addr.user.as_str())
         .region(Region::new(region.clone()))
@@ -88,6 +90,7 @@ mod tests {
     use pgdog_config::Role;
 
     use super::*;
+    use crate::backend::pool::transport::Transport;
     use crate::config::ServerAuth;
     use crate::test_utils::set_env_var;
 

pgdog/src/backend/auth/vault.rs

@@ -151,6 +151,7 @@ mod tests {
 
     use super::*;
     use crate::auth::vault::{VAULT_TOKEN, VaultToken};
+    use crate::backend::pool::transport::Transport;
     use crate::config::ConfigAndUsers;
 
     fn setup() {

pgdog/src/backend/error.rs

@@ -1,6 +1,6 @@
 use thiserror::Error;
 
-use crate::net::messages::ErrorResponse;
+use crate::{backend::pool::transport::TransportError, net::messages::ErrorResponse};
 
 use super::databases::User;
 
@@ -146,6 +146,9 @@ pub enum Error {
 
     #[error("missing canonical oid for type {0}")]
     MissingCanonicalOid(String),
+
+    #[error(transparent)]
+    Transport(#[from] TransportError),
 }
 
 impl From<crate::frontend::Error> for Error {