319 lines
11 KiB
Rust
319 lines
11 KiB
Rust
use crate::path_utils::expand_tilde;
|
|
use reqwest::ClientBuilder;
|
|
use reqwest::{Certificate, Identity};
|
|
use std::fmt;
|
|
use std::future::Future;
|
|
use std::time::Duration;
|
|
|
|
// Re-export types so that `db::QueryResult` etc. work within dbx-core
|
|
pub use crate::file_validator::validate_file_path;
|
|
pub use crate::types::*;
|
|
|
|
pub const CONNECTION_TIMEOUT_SECS: u64 = 5;
|
|
pub const TCP_PROBE_TIMEOUT_SECS: u64 = 3;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum PoolCheckoutStage {
|
|
Wait,
|
|
Create,
|
|
Recycle,
|
|
Unknown,
|
|
}
|
|
|
|
impl PoolCheckoutStage {
|
|
pub fn as_str(self) -> &'static str {
|
|
match self {
|
|
Self::Wait => "wait",
|
|
Self::Create => "create",
|
|
Self::Recycle => "recycle",
|
|
Self::Unknown => "unknown",
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub enum PoolCheckoutError {
|
|
Timeout { database: &'static str, stage: PoolCheckoutStage, timeout: Duration },
|
|
Failed { database: &'static str, stage: PoolCheckoutStage, detail: String },
|
|
Canceled,
|
|
}
|
|
|
|
impl PoolCheckoutError {
|
|
pub fn stage(&self) -> Option<PoolCheckoutStage> {
|
|
match self {
|
|
Self::Timeout { stage, .. } | Self::Failed { stage, .. } => Some(*stage),
|
|
Self::Canceled => None,
|
|
}
|
|
}
|
|
|
|
pub fn is_pool_saturation(&self) -> bool {
|
|
matches!(self, Self::Timeout { stage: PoolCheckoutStage::Wait, .. })
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for PoolCheckoutError {
|
|
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Self::Timeout { database, stage, timeout } => write!(
|
|
formatter,
|
|
"{database} connection pool checkout timed out [stage={}, timeout_ms={}]",
|
|
stage.as_str(),
|
|
timeout.as_millis()
|
|
),
|
|
Self::Failed { database, stage, detail } => {
|
|
write!(formatter, "{database} connection pool checkout failed [stage={}]: {detail}", stage.as_str())
|
|
}
|
|
Self::Canceled => formatter.write_str(crate::execution::QUERY_CANCELED),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn connection_timeout() -> Duration {
|
|
Duration::from_secs(CONNECTION_TIMEOUT_SECS)
|
|
}
|
|
|
|
pub fn http_client_builder(timeout: Duration) -> ClientBuilder {
|
|
reqwest::Client::builder().connect_timeout(timeout).no_proxy()
|
|
}
|
|
|
|
/// Augments an HTTP client builder with custom TLS material for drivers that
|
|
/// need to trust a non-system CA or present a client certificate (mTLS).
|
|
///
|
|
/// * `ca_cert_path` adds an extra root certificate (PEM bundle) alongside the
|
|
/// system roots, so self-signed server certificates are trusted.
|
|
/// * `client_cert_path` + `client_key_path` (required together) are concatenated
|
|
/// into a single PEM identity, as expected by reqwest's rustls backend.
|
|
///
|
|
/// Returns the augmented builder, or a descriptive error if a configured
|
|
/// certificate/key file cannot be read or parsed. Callers surface that error
|
|
/// instead of silently falling back to the system trust store, so a typo in a
|
|
/// cert path fails the connection loudly rather than being ignored.
|
|
pub fn apply_tls_certificates(
|
|
mut builder: ClientBuilder,
|
|
ca_cert_path: Option<&str>,
|
|
client_cert_path: Option<&str>,
|
|
client_key_path: Option<&str>,
|
|
) -> Result<ClientBuilder, String> {
|
|
// The desktop build unifies reqwest with both `default-tls` and `rustls-tls`,
|
|
// and `TlsBackend` defaults to native-tls there, which rejects the PEM identity
|
|
// below with `incompatible TLS identity type`. Pin rustls like the Consul and
|
|
// etcd-metrics clients so custom CA roots and PEM client identities work in
|
|
// every target.
|
|
builder = builder.use_rustls_tls();
|
|
if let Some(ca) = ca_cert_path.filter(|path| !path.is_empty()) {
|
|
let ca = expand_tilde(ca);
|
|
let contents = std::fs::read(&ca)
|
|
.map_err(|error| format!("Failed to read Elasticsearch CA certificate at {ca}: {error}"))?;
|
|
let certificates = Certificate::from_pem_bundle(&contents)
|
|
.map_err(|error| format!("Failed to parse Elasticsearch CA certificate at {ca}: {error}"))?;
|
|
for certificate in certificates {
|
|
builder = builder.add_root_certificate(certificate);
|
|
}
|
|
}
|
|
if let (Some(cert_path), Some(key_path)) =
|
|
(client_cert_path.filter(|path| !path.is_empty()), client_key_path.filter(|path| !path.is_empty()))
|
|
{
|
|
let cert_path = expand_tilde(cert_path);
|
|
let key_path = expand_tilde(key_path);
|
|
let mut pem = std::fs::read(&cert_path)
|
|
.map_err(|error| format!("Failed to read Elasticsearch client certificate at {cert_path}: {error}"))?;
|
|
// reqwest's rustls backend concatenates the cert and key as two PEM
|
|
// blocks; ensure they are newline-separated so parsing succeeds even
|
|
// when the cert file does not end with a trailing newline.
|
|
if !pem.ends_with(b"\n") {
|
|
pem.push(b'\n');
|
|
}
|
|
pem.extend(
|
|
std::fs::read(&key_path)
|
|
.map_err(|error| format!("Failed to read Elasticsearch client key at {key_path}: {error}"))?,
|
|
);
|
|
let identity = Identity::from_pem(&pem)
|
|
.map_err(|error| format!("Failed to parse Elasticsearch client identity: {error}"))?;
|
|
builder = builder.identity(identity);
|
|
}
|
|
Ok(builder)
|
|
}
|
|
|
|
pub use dbx_types::json::JS_MAX_SAFE_INTEGER;
|
|
pub use dbx_types::json::{json_value_for_js, safe_i64_to_json, safe_u64_to_json};
|
|
|
|
pub fn hex_encode(bytes: &[u8]) -> String {
|
|
const HEX: &[u8; 16] = b"0123456789abcdef";
|
|
let mut out = String::with_capacity(bytes.len() * 2);
|
|
for &byte in bytes {
|
|
out.push(HEX[(byte >> 4) as usize] as char);
|
|
out.push(HEX[(byte & 0x0f) as usize] as char);
|
|
}
|
|
out
|
|
}
|
|
|
|
pub fn binary_value_to_json(bytes: &[u8]) -> serde_json::Value {
|
|
serde_json::Value::String(format!("0x{}", hex_encode(bytes)))
|
|
}
|
|
|
|
pub fn tcp_probe_timeout() -> Duration {
|
|
Duration::from_secs(TCP_PROBE_TIMEOUT_SECS)
|
|
}
|
|
|
|
pub fn parse_connect_timeout(url: &str) -> Duration {
|
|
parse_connect_timeout_with_fallback(url, connection_timeout())
|
|
}
|
|
|
|
pub fn parse_connect_timeout_with_fallback(url: &str, fallback: Duration) -> Duration {
|
|
let Some(query) = url.split('?').nth(1) else {
|
|
return fallback;
|
|
};
|
|
for param in query.split('&') {
|
|
let trimmed = param.trim();
|
|
if trimmed.is_empty() {
|
|
continue;
|
|
}
|
|
let (key, value) = match trimmed.split_once('=') {
|
|
Some(pair) => pair,
|
|
None => continue,
|
|
};
|
|
if key.eq_ignore_ascii_case("connect_timeout")
|
|
|| key.eq_ignore_ascii_case("connectTimeout")
|
|
|| key.eq_ignore_ascii_case("connection_timeout")
|
|
|| key.eq_ignore_ascii_case("connectionTimeout")
|
|
{
|
|
if let Ok(v) = value.parse::<u64>() {
|
|
if (1..=300).contains(&v) {
|
|
return Duration::from_secs(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fallback
|
|
}
|
|
|
|
pub async fn with_connection_timeout<T, F>(label: &str, timeout: Duration, future: F) -> Result<T, String>
|
|
where
|
|
F: Future<Output = Result<T, String>>,
|
|
{
|
|
tokio::time::timeout(timeout, future)
|
|
.await
|
|
.map_err(|_| format!("{label} connection timed out ({}s)", timeout.as_secs()))?
|
|
}
|
|
|
|
pub async fn probe_tcp_endpoint(label: &str, host: &str, port: u16, timeout: Duration) -> Result<(), String> {
|
|
tokio::time::timeout(timeout, tokio::net::TcpStream::connect((host, port)))
|
|
.await
|
|
.map_err(|_| format!("{label} TCP connection timed out ({}s)", timeout.as_secs()))?
|
|
.map(|_| ())
|
|
.map_err(|e| format!("{label} TCP connection failed: {e}"))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn binary_values_are_displayed_as_prefixed_hex() {
|
|
assert_eq!(binary_value_to_json(&[0x00, 0x01, 0xab, 0xff]), serde_json::json!("0x0001abff"));
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tls_tests {
|
|
use super::{apply_tls_certificates, http_client_builder};
|
|
use std::path::Path;
|
|
use std::process::Command;
|
|
use std::time::Duration;
|
|
|
|
/// Generates a throwaway CA + client certificate/key (PEM) via openssl and
|
|
/// returns their paths. If openssl is unavailable the files stay empty, which
|
|
/// makes `apply_tls_certificates` surface a read error instead of degrading.
|
|
fn gen_certs(dir: &Path) -> (std::path::PathBuf, std::path::PathBuf, std::path::PathBuf) {
|
|
let ca_key = dir.join("ca.key");
|
|
let ca_pem = dir.join("ca.pem");
|
|
let csr = dir.join("client.csr");
|
|
let client_key = dir.join("client.key");
|
|
let client_crt = dir.join("client.crt");
|
|
// Extensions force an X.509 v3 client cert; some toolchains (e.g.
|
|
// OpenSSL 3.0 on CI) emit v1 without one, which rustls rejects.
|
|
let client_ext = dir.join("client.ext");
|
|
let _ = std::fs::write(&client_ext, "basicConstraints=critical,CA:FALSE\n");
|
|
let _ = Command::new("openssl")
|
|
.args([
|
|
"req",
|
|
"-x509",
|
|
"-newkey",
|
|
"rsa:2048",
|
|
"-nodes",
|
|
"-keyout",
|
|
ca_key.to_str().unwrap(),
|
|
"-out",
|
|
ca_pem.to_str().unwrap(),
|
|
"-days",
|
|
"1",
|
|
"-subj",
|
|
"/CN=dbx-test-ca",
|
|
])
|
|
.output();
|
|
let _ = Command::new("openssl")
|
|
.args([
|
|
"req",
|
|
"-newkey",
|
|
"rsa:2048",
|
|
"-nodes",
|
|
"-keyout",
|
|
client_key.to_str().unwrap(),
|
|
"-out",
|
|
csr.to_str().unwrap(),
|
|
"-subj",
|
|
"/CN=dbx-test-client",
|
|
])
|
|
.output();
|
|
let _ = Command::new("openssl")
|
|
.args([
|
|
"x509",
|
|
"-req",
|
|
"-in",
|
|
csr.to_str().unwrap(),
|
|
"-CA",
|
|
ca_pem.to_str().unwrap(),
|
|
"-CAkey",
|
|
ca_key.to_str().unwrap(),
|
|
"-CAcreateserial",
|
|
"-out",
|
|
client_crt.to_str().unwrap(),
|
|
"-days",
|
|
"1",
|
|
"-extfile",
|
|
client_ext.to_str().unwrap(),
|
|
])
|
|
.output();
|
|
(ca_pem, client_crt, client_key)
|
|
}
|
|
|
|
#[test]
|
|
fn apply_tls_certificates_builds_with_ca_and_client_cert() {
|
|
let dir = std::env::temp_dir().join(format!("dbx-tls-test-{}", std::process::id()));
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
let (ca, client_crt, client_key) = gen_certs(&dir);
|
|
|
|
let built = apply_tls_certificates(
|
|
http_client_builder(Duration::from_secs(5)),
|
|
ca.to_str(),
|
|
client_crt.to_str(),
|
|
client_key.to_str(),
|
|
)
|
|
.expect("client should build with CA + client cert")
|
|
.build();
|
|
assert!(built.is_ok(), "built client should be usable with CA + client cert: {:?}", built.err());
|
|
|
|
// A misconfigured CA path must now surface a descriptive error instead of
|
|
// silently degrading to the system trust store.
|
|
let missing = apply_tls_certificates(
|
|
http_client_builder(Duration::from_secs(5)),
|
|
Some("/nonexistent/ca.pem"),
|
|
None,
|
|
None,
|
|
);
|
|
assert!(missing.is_err(), "missing CA path must surface a read error");
|
|
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
}
|
|
}
|