use super::profile::Profile;
use super::tls::{self, Encryption, Verification};
use crate::error::{Failure, Result};
use mysql_async::{Opts, OptsBuilder, WhiteListFsHandler};
use secrecy::{ExposeSecret, SecretString};
use std::collections::HashMap;
use std::path::PathBuf;
use std::time::Duration;
pub const AUTOCOMMIT_OFF: &str = "SET autocommit = 0";
pub const READ_ONLY_BLOCK: &str = "START TRANSACTION READ ONLY";
const CLEAR_PASSWORD: &str = "mysql_clear_password";
#[allow(clippy::struct_excessive_bools)]
#[derive(Debug, Clone)]
pub struct ConnectionSettings {
pub secret: Option<SecretString>,
pub default_port: u16,
pub prefer_socket: bool,
pub compress: bool,
pub max_allowed_packet: Option<usize>,
pub wait_timeout: Option<usize>,
pub tcp_keepalive: Option<Duration>,
pub stmt_cache_size: usize,
pub count_matched_rows: bool,
pub verification: Verification,
pub encryption: Encryption,
pub timezone: Option<String>,
pub charset: Option<String>,
pub session_setup: Vec<String>,
pub local_file_read: bool,
pub readable_local_files: Vec<PathBuf>,
pub connect_attributes: HashMap<String, String>,
pub refuse_change: bool,
pub statement_budget: Option<Duration>,
}
pub fn build(profile: &Profile, settings: &ConnectionSettings) -> Result<Opts> {
profile.ensure_reachable()?;
let mut builder = OptsBuilder::default()
.enable_cleartext_plugin(wants_clear_password(profile)?)
.user(profile.user.clone())
.db_name(profile.database.clone())
.tcp_port(profile.port.unwrap_or(settings.default_port))
.prefer_socket(settings.prefer_socket)
.stmt_cache_size(settings.stmt_cache_size)
.client_found_rows(settings.count_matched_rows)
.max_allowed_packet(settings.max_allowed_packet)
.wait_timeout(settings.wait_timeout)
.tcp_keepalive(settings.tcp_keepalive)
.setup(session_setup(profile, settings)?)
.ssl_opts(tls::channel(profile, &settings.encryption)?);
builder = builder.local_infile_handler(
settings
.local_file_read
.then(|| WhiteListFsHandler::new(settings.readable_local_files.clone())),
);
if let Some(host) = &profile.host {
builder = builder.ip_or_hostname(host.clone());
}
if let Some(socket) = &profile.socket {
builder = builder.socket(Some(socket.to_string_lossy().into_owned()));
}
if let Some(secret) = &settings.secret {
builder = builder.pass(Some(secret.expose_secret().to_owned()));
}
if settings.compress {
builder = builder.compression(mysql_async::Compression::default());
}
if !settings.connect_attributes.is_empty() {
builder = builder.connect_attributes(settings.connect_attributes.clone());
}
Ok(Opts::from(builder))
}
fn wants_clear_password(profile: &Profile) -> Result<bool> {
let Some(declared) = &profile.auth_method else {
return Ok(false);
};
match declared.trim().to_ascii_lowercase().as_str() {
CLEAR_PASSWORD => Ok(true),
"mysql_native_password"
| "caching_sha2_password"
| "client_ed25519"
| "ed25519"
| "parsec" => Ok(false),
_ => Err(super::unsupported_auth_method(declared)),
}
}
fn session_setup(profile: &Profile, settings: &ConnectionSettings) -> Result<Vec<String>> {
let mut setup =
Vec::with_capacity(profile.session_setup.len() + settings.session_setup.len() + 5);
setup.push(AUTOCOMMIT_OFF.to_owned());
if let Some(budget) = settings.statement_budget {
setup.push(statement_budget(budget));
}
if let Some(charset) = &settings.charset {
setup.push(format!(
"SET NAMES '{}'",
plain_name("conn.charset", charset)?
));
}
if let Some(timezone) = &settings.timezone {
setup.push(format!(
"SET time_zone = '{}'",
plain_name("conn.timezone", timezone)?
));
}
setup.extend(settings.session_setup.iter().cloned());
setup.extend(profile.session_setup.iter().cloned());
if settings.refuse_change {
setup.push(READ_ONLY_BLOCK.to_owned());
}
Ok(setup)
}
fn plain_name<'a>(key: &str, value: &'a str) -> Result<&'a str> {
let acceptable = |character: char| {
character.is_ascii_alphanumeric() || matches!(character, '_' | '-' | '+' | ':' | '/' | '.')
};
if value.is_empty() || !value.chars().all(acceptable) {
return Err(Failure::config(
"config.declared_name_is_not_one",
format!("`{value}` is not something `{key}` can declare on a session"),
)
.with_detail("detail", value)
.with_hint("use a plain name such as utf8mb4, UTC, +00:00 or Europe/Lisbon"));
}
Ok(value)
}
fn statement_budget(budget: Duration) -> String {
format!("SET SESSION max_statement_time = {}", budget.as_secs_f64())
}
#[cfg(test)]
mod tests {
use super::*;
fn settings() -> ConnectionSettings {
ConnectionSettings {
secret: None,
default_port: 3306,
prefer_socket: true,
compress: false,
max_allowed_packet: Some(16 * 1024 * 1024),
wait_timeout: Some(600),
tcp_keepalive: Some(Duration::from_secs(30)),
stmt_cache_size: 32,
count_matched_rows: true,
verification: Verification::default(),
encryption: Encryption::default(),
timezone: None,
charset: None,
session_setup: Vec::new(),
local_file_read: false,
readable_local_files: Vec::new(),
connect_attributes: HashMap::new(),
refuse_change: false,
statement_budget: None,
}
}
fn profile() -> Profile {
Profile {
host: Some("db.example".to_owned()),
user: Some("reader".to_owned()),
database: Some("sales".to_owned()),
..Profile::named("main")
}
}
#[test]
fn the_destination_reaches_the_driver() {
let opts = build(&profile(), &settings()).expect("builds");
assert_eq!(opts.ip_or_hostname(), "db.example");
assert_eq!(opts.user(), Some("reader"));
assert_eq!(opts.db_name(), Some("sales"));
}
#[test]
fn an_absent_port_takes_the_configured_default() {
let mut settings = settings();
settings.default_port = 3307;
assert_eq!(
build(&profile(), &settings).expect("builds").tcp_port(),
3307
);
let pinned = Profile {
port: Some(3399),
..profile()
};
assert_eq!(build(&pinned, &settings).expect("builds").tcp_port(), 3399);
}
#[test]
fn automatic_confirmation_is_switched_off_first() {
let profile = Profile {
session_setup: vec!["SET time_zone = '+00:00'".to_owned()],
..profile()
};
let opts = build(&profile, &settings()).expect("builds");
assert_eq!(
opts.setup().first().map(String::as_str),
Some(AUTOCOMMIT_OFF)
);
assert_eq!(opts.setup().len(), 2);
}
#[test]
fn the_change_count_meaning_follows_the_setting() {
let mut settings = settings();
assert!(build(&profile(), &settings)
.expect("builds")
.client_found_rows());
settings.count_matched_rows = false;
assert!(!build(&profile(), &settings)
.expect("builds")
.client_found_rows());
}
#[test]
fn the_secret_reaches_the_driver_only() {
let mut settings = settings();
settings.secret = Some(SecretString::from("hunter2"));
let opts = build(&profile(), &settings).expect("builds");
assert_eq!(opts.pass(), Some("hunter2"));
let stored = toml::to_string(&profile()).expect("serialises");
assert!(
!stored.contains("hunter2"),
"the profile carries a secret: {stored}"
);
}
#[test]
fn a_socket_destination_needs_no_host() {
let profile = Profile {
socket: Some(std::path::PathBuf::from("/run/mysqld/mysqld.sock")),
..Profile::named("local")
};
let opts = build(&profile, &settings()).expect("builds");
assert_eq!(opts.socket(), Some("/run/mysqld/mysqld.sock"));
assert!(opts.prefer_socket());
}
#[test]
fn a_destination_naming_no_server_is_refused() {
let failure = build(&Profile::named("empty"), &settings()).expect_err("must refuse");
assert_eq!(failure.code(), "profile.no_destination");
}
#[test]
fn the_liveness_interval_reaches_the_driver() {
let opts = build(&profile(), &settings()).expect("builds");
assert_eq!(opts.tcp_keepalive(), Some(Duration::from_secs(30)));
}
#[test]
fn the_declared_character_set_and_zone_reach_the_session() {
let mut settings = settings();
settings.charset = Some("utf8mb4".to_owned());
settings.timezone = Some("+00:00".to_owned());
let opts = build(&profile(), &settings).expect("builds");
let setup = opts.setup();
let charset = setup
.iter()
.position(|line| line == "SET NAMES 'utf8mb4'")
.expect("the character set is declared");
let zone = setup
.iter()
.position(|line| line == "SET time_zone = '+00:00'")
.expect("the zone is declared");
assert!(
charset < zone,
"text is read the declared way first: {setup:?}"
);
}
#[test]
fn nothing_is_declared_when_nothing_was_stored() {
let opts = build(&profile(), &settings()).expect("builds");
assert!(!opts
.setup()
.iter()
.any(|line| line.contains("SET NAMES") || line.contains("time_zone")));
}
#[test]
fn a_declared_name_that_is_not_one_is_refused() {
let mut settings = settings();
settings.timezone = Some("'; DROP TABLE t; --".to_owned());
let failure = build(&profile(), &settings).expect_err("must refuse");
assert_eq!(failure.code(), "config.declared_name_is_not_one");
}
#[test]
fn the_stored_adjustments_run_before_the_destinations_own() {
let profile = Profile {
session_setup: vec!["SET sql_mode = 'STRICT_ALL_TABLES'".to_owned()],
..profile()
};
let mut settings = settings();
settings.session_setup = vec!["SET sql_mode = 'ANSI'".to_owned()];
let opts = build(&profile, &settings).expect("builds");
let setup = opts.setup();
let stored = setup
.iter()
.position(|line| line.contains("ANSI"))
.expect("the stored adjustment is applied");
let own = setup
.iter()
.position(|line| line.contains("STRICT_ALL_TABLES"))
.expect("the destination's own adjustment is applied");
assert!(stored < own, "the destination has the last word: {setup:?}");
}
#[test]
fn no_handler_is_registered_until_the_permission_is_given() {
let opts = build(&profile(), &settings()).expect("builds");
assert!(
opts.local_infile_handler().is_none(),
"the refusal is the absence of a handler"
);
}
#[test]
fn the_permission_registers_a_handler_over_the_named_files_alone() {
let mut settings = settings();
settings.local_file_read = true;
settings.readable_local_files = vec![std::path::PathBuf::from("/tmp/rows.csv")];
let opts = build(&profile(), &settings).expect("builds");
assert!(opts.local_infile_handler().is_some());
}
#[cfg(feature = "tls")]
#[test]
fn the_stored_demand_for_encryption_reaches_the_channel() {
let mut settings = settings();
assert!(build(&profile(), &settings)
.expect("builds")
.ssl_opts()
.is_none());
settings.encryption.demanded = true;
assert!(build(&profile(), &settings)
.expect("builds")
.ssl_opts()
.is_some());
}
#[cfg(not(feature = "tls"))]
#[test]
fn a_build_without_encryption_refuses_a_destination_that_demands_it() {
let profile = Profile {
require_tls: Some(true),
..profile()
};
let failure = build(&profile, &settings()).expect_err("must refuse");
assert_eq!(failure.code(), "tls.not_available");
assert_eq!(failure.exit_number().code(), 4);
}
#[cfg(feature = "tls")]
#[test]
fn a_build_with_encryption_accepts_a_destination_that_demands_it() {
let profile = Profile {
require_tls: Some(true),
..profile()
};
let opts = build(&profile, &settings()).expect("encryption is available");
assert!(
opts.ssl_opts().is_some(),
"a destination that demands encryption must get an encrypted channel"
);
}
#[test]
fn refusing_change_opens_a_read_only_block_on_the_server() {
let mut settings = settings();
settings.refuse_change = true;
let opts = build(&profile(), &settings).expect("builds");
assert_eq!(
opts.setup().last().map(String::as_str),
Some(READ_ONLY_BLOCK),
"the block must be the last thing set up, after every adjustment"
);
}
#[test]
fn accepting_change_opens_no_block() {
let opts = build(&profile(), &settings()).expect("builds");
assert!(!opts.setup().iter().any(|line| line == READ_ONLY_BLOCK));
}
#[test]
fn the_time_budget_reaches_the_server_as_a_session_adjustment() {
let mut settings = settings();
settings.statement_budget = Some(Duration::from_secs(5));
let opts = build(&profile(), &settings).expect("builds");
assert!(opts
.setup()
.iter()
.any(|line| line == "SET SESSION max_statement_time = 5"));
}
#[test]
fn a_budget_shorter_than_a_second_is_not_rounded_away() {
assert_eq!(
statement_budget(Duration::from_millis(250)),
"SET SESSION max_statement_time = 0.25"
);
}
#[test]
fn the_budget_is_set_before_the_block_opens() {
let mut settings = settings();
settings.refuse_change = true;
settings.statement_budget = Some(Duration::from_secs(5));
let opts = build(&profile(), &settings).expect("builds");
let setup = opts.setup();
let budget = setup
.iter()
.position(|line| line.contains("max_statement_time"))
.expect("the budget is set up");
let block = setup
.iter()
.position(|line| line == READ_ONLY_BLOCK)
.expect("the block is set up");
assert!(budget < block, "the budget must come first: {setup:?}");
}
}