Joseph Doherty
127 lines
3.2 KiB
Rust
127 lines
3.2 KiB
Rust
use std::fmt;
|
|
use std::path::PathBuf;
|
|
use std::time::Duration;
|
|
|
|
use crate::auth::ApiKey;
|
|
|
|
#[derive(Clone)]
|
|
pub struct ClientOptions {
|
|
endpoint: String,
|
|
api_key: Option<ApiKey>,
|
|
plaintext: bool,
|
|
ca_file: Option<PathBuf>,
|
|
server_name_override: Option<String>,
|
|
connect_timeout: Duration,
|
|
call_timeout: Duration,
|
|
}
|
|
|
|
impl ClientOptions {
|
|
pub fn new(endpoint: impl Into<String>) -> Self {
|
|
Self {
|
|
endpoint: endpoint.into(),
|
|
api_key: None,
|
|
plaintext: true,
|
|
ca_file: None,
|
|
server_name_override: None,
|
|
connect_timeout: Duration::from_secs(10),
|
|
call_timeout: Duration::from_secs(30),
|
|
}
|
|
}
|
|
|
|
pub fn with_api_key(mut self, api_key: ApiKey) -> Self {
|
|
self.api_key = Some(api_key);
|
|
self
|
|
}
|
|
|
|
pub fn with_plaintext(mut self, plaintext: bool) -> Self {
|
|
self.plaintext = plaintext;
|
|
self
|
|
}
|
|
|
|
pub fn with_ca_file(mut self, ca_file: impl Into<PathBuf>) -> Self {
|
|
self.ca_file = Some(ca_file.into());
|
|
self
|
|
}
|
|
|
|
pub fn with_server_name_override(mut self, server_name_override: impl Into<String>) -> Self {
|
|
self.server_name_override = Some(server_name_override.into());
|
|
self
|
|
}
|
|
|
|
pub fn with_connect_timeout(mut self, connect_timeout: Duration) -> Self {
|
|
self.connect_timeout = connect_timeout;
|
|
self
|
|
}
|
|
|
|
pub fn with_call_timeout(mut self, call_timeout: Duration) -> Self {
|
|
self.call_timeout = call_timeout;
|
|
self
|
|
}
|
|
|
|
pub fn endpoint(&self) -> &str {
|
|
&self.endpoint
|
|
}
|
|
|
|
pub fn api_key(&self) -> Option<&ApiKey> {
|
|
self.api_key.as_ref()
|
|
}
|
|
|
|
pub fn plaintext(&self) -> bool {
|
|
self.plaintext
|
|
}
|
|
|
|
pub fn ca_file(&self) -> Option<&PathBuf> {
|
|
self.ca_file.as_ref()
|
|
}
|
|
|
|
pub fn server_name_override(&self) -> Option<&str> {
|
|
self.server_name_override.as_deref()
|
|
}
|
|
|
|
pub fn connect_timeout(&self) -> Duration {
|
|
self.connect_timeout
|
|
}
|
|
|
|
pub fn call_timeout(&self) -> Duration {
|
|
self.call_timeout
|
|
}
|
|
}
|
|
|
|
impl Default for ClientOptions {
|
|
fn default() -> Self {
|
|
Self::new("http://127.0.0.1:5000")
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for ClientOptions {
|
|
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
formatter
|
|
.debug_struct("ClientOptions")
|
|
.field("endpoint", &self.endpoint)
|
|
.field("api_key", &self.api_key.as_ref().map(|_| "<redacted>"))
|
|
.field("plaintext", &self.plaintext)
|
|
.field("ca_file", &self.ca_file)
|
|
.field("server_name_override", &self.server_name_override)
|
|
.field("connect_timeout", &self.connect_timeout)
|
|
.field("call_timeout", &self.call_timeout)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::ClientOptions;
|
|
use crate::auth::ApiKey;
|
|
|
|
#[test]
|
|
fn debug_redacts_api_key() {
|
|
let options =
|
|
ClientOptions::new("http://localhost:5000").with_api_key(ApiKey::new("mxgw_secret"));
|
|
|
|
let debug = format!("{options:?}");
|
|
|
|
assert!(debug.contains("<redacted>"));
|
|
assert!(!debug.contains("mxgw_secret"));
|
|
}
|
|
}
|