use crate::config::ConfigError;
use std::{fmt, path::PathBuf, str::FromStr};
#[derive(Clone)]
pub struct SecretString(String);
pub fn deserialize_secret<'de, D, T>(deserializer: D) -> Result<T, D::Error>
where
D: serde::Deserializer<'de>,
T: serde::Deserialize<'de>,
{
T::deserialize(deserializer).map_err(|_| serde::de::Error::custom("invalid secret value"))
}
impl<'de> serde::Deserialize<'de> for SecretString {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
deserialize_secret(deserializer).map(Self)
}
}
impl SecretString {
pub fn new(value: String) -> Self {
Self(value)
}
}
impl std::ops::Deref for SecretString {
type Target = str;
fn deref(&self) -> &str {
&self.0
}
}
impl fmt::Debug for SecretString {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("[REDACTED]")
}
}
impl FromStr for SecretString {
type Err = std::convert::Infallible;
fn from_str(value: &str) -> Result<Self, Self::Err> {
Ok(Self(value.to_owned()))
}
}
#[derive(Clone)]
pub enum TextSource {
Inline(SecretString),
File(PathBuf),
}
impl TextSource {
pub fn read(&self, label: &str) -> Result<String, ConfigError> {
match self {
Self::Inline(value) => Ok(value.to_string()),
Self::File(path) => std::fs::read_to_string(path)
.map(|value| value.trim_end_matches(['\r', '\n']).to_owned())
.map_err(|source| ConfigError::SecretRead {
secret: label.to_owned(),
path: path.clone(),
source,
}),
}
}
}
#[derive(serde::Deserialize)]
#[serde(deny_unknown_fields)]
struct FileReference {
file: PathBuf,
}
impl<'de> serde::Deserialize<'de> for TextSource {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
#[derive(serde::Deserialize)]
#[serde(untagged)]
enum Shape {
Inline(String),
File(FileReference),
}
match Shape::deserialize(deserializer)
.map_err(|_| serde::de::Error::custom("expected a string or { file = \"/path\" }"))?
{
Shape::Inline(value) => Ok(Self::Inline(SecretString(value))),
Shape::File(reference) => Ok(Self::File(reference.file)),
}
}
}
impl FromStr for TextSource {
type Err = String;
fn from_str(value: &str) -> Result<Self, Self::Err> {
if value.trim_start().starts_with('{') {
#[derive(serde::Deserialize)]
struct Wrapper {
value: FileReference,
}
return toml::from_str::<Wrapper>(&format!("value = {value}"))
.map(|wrapper| Self::File(wrapper.value.file))
.map_err(|_| "expected { file = \"/path\" }".to_owned());
}
Ok(Self::Inline(SecretString(value.to_owned())))
}
}
impl fmt::Debug for TextSource {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Inline(_) => f.write_str("Inline([REDACTED])"),
Self::File(path) => f.debug_tuple("File").field(path).finish(),
}
}
}