use std::time::Duration;
use tonic::transport::ClientTlsConfig;
use crate::error::{ArcadeDbError, Result};
#[derive(Clone, Debug)]
pub struct ClientOptions {
pub(crate) addr: String,
pub(crate) user: String,
pub(crate) pass: String,
pub(crate) database: String,
pub(crate) tls: Option<ClientTlsConfig>,
pub(crate) connect_timeout: Option<Duration>,
pub(crate) connect_attempts: u32,
pub(crate) connect_backoff: Duration,
pub(crate) request_timeout: Option<Duration>,
pub(crate) open_or_create: bool,
}
impl ClientOptions {
pub fn new(
addr: impl Into<String>,
user: impl Into<String>,
pass: impl Into<String>,
database: impl Into<String>,
) -> Self {
Self {
addr: addr.into(),
user: user.into(),
pass: pass.into(),
database: database.into(),
tls: None,
connect_timeout: None,
connect_attempts: 30,
connect_backoff: Duration::from_millis(400),
request_timeout: None,
open_or_create: false,
}
}
pub fn open_or_create(mut self, yes: bool) -> Self {
self.open_or_create = yes;
self
}
pub fn tls(mut self, config: ClientTlsConfig) -> Self {
self.tls = Some(config);
self
}
pub fn connect_timeout(mut self, timeout: Duration) -> Self {
self.connect_timeout = Some(timeout);
self
}
pub fn connect_attempts(mut self, attempts: u32) -> Self {
self.connect_attempts = attempts.max(1);
self
}
pub fn connect_backoff(mut self, backoff: Duration) -> Self {
self.connect_backoff = backoff;
self
}
pub fn request_timeout(mut self, timeout: Duration) -> Self {
self.request_timeout = Some(timeout);
self
}
pub fn from_env() -> Result<Self> {
Self::from_env_prefix("ARCADEDB")
}
pub fn from_env_prefix(prefix: &str) -> Result<Self> {
let get = |suffix: &str| -> Result<String> {
let name = format!("{prefix}_{suffix}");
std::env::var(&name)
.ok()
.filter(|v| !v.is_empty())
.ok_or_else(|| ArcadeDbError::InvalidInput {
message: format!(
"ClientOptions::from_env: environment variable `{name}` is not set"
),
})
};
Ok(Self::new(
get("ADDR")?,
get("USER")?,
get("PASSWORD")?,
get("DATABASE")?,
))
}
pub(crate) fn validate(&self) -> Result<()> {
let check = |value: &str, what: &str| -> Result<()> {
if value.is_empty() {
return Err(ArcadeDbError::InvalidInput {
message: format!("ClientOptions: {what} must not be empty"),
});
}
if value.parse::<tonic::metadata::MetadataValue<_>>().is_err() {
return Err(ArcadeDbError::InvalidInput {
message: format!(
"ClientOptions: {what} contains characters invalid in a gRPC metadata value (visible ASCII only)"
),
});
}
Ok(())
};
check(&self.addr, "addr")?;
check(&self.user, "user")?;
check(&self.pass, "password")?;
check(&self.database, "database")?;
Ok(())
}
}