main
use std::time::{Duration, Instant};
use base64::Engine;
use config::smtp::SmtpSecurity;
use lettre::address::Address;
use lettre::message::header::ContentType;
use lettre::message::{
Attachment as LettreAttachment, Mailbox, Message, MessageBuilder, MultiPart, SinglePart,
};
use lettre::transport::smtp::AsyncSmtpTransport;
use lettre::transport::smtp::authentication::{Credentials, Mechanism};
use lettre::{AsyncTransport, Tokio1Executor};
use tracing::debug;
use crate::error::EmailError;
use crate::events::{EmailAddress, SendEmailRequest};
pub struct EmailTransport {
inner: AsyncSmtpTransport<Tokio1Executor>,
}
impl EmailTransport {
#[tracing::instrument(skip_all, fields(request_id = %_request_id.unwrap_or_default()))]
pub async fn send(
&self,
msg: Message,
_request_id: Option<&str>,
) -> Result<String, EmailError> {
let started = Instant::now();
let response = self.inner.send(msg).await?;
let id = response.message().next().unwrap_or_default().to_string();
let id_short: String = id.chars().take(16).collect();
debug!(
elapsed_ms = started.elapsed().as_millis() as u64,
message_id = %id_short,
"smtp response received"
);
Ok(id)
}
}
impl Clone for EmailTransport {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
}
pub struct EmailTransportBuilder {
host: String,
port: u16,
security: SmtpSecurity,
username: Option<String>,
password: Option<String>,
connection_timeout: Option<Duration>,
}
impl EmailTransportBuilder {
pub fn new(
host: impl Into<String>,
port: u16,
security: SmtpSecurity,
username: Option<String>,
password: Option<String>,
) -> Self {
Self {
host: host.into(),
port,
security,
username,
password,
connection_timeout: None,
}
}
pub fn connection_timeout(mut self, dur: Duration) -> Self {
self.connection_timeout = Some(dur);
self
}
pub fn build(self) -> Result<EmailTransport, EmailError> {
if self.host.is_empty() {
return Err(EmailError::Config("smtp host is empty".into()));
}
let mut builder = match self.security {
SmtpSecurity::Tls => AsyncSmtpTransport::<Tokio1Executor>::relay(&self.host)?,
SmtpSecurity::StartTls => {
AsyncSmtpTransport::<Tokio1Executor>::starttls_relay(&self.host)?
}
SmtpSecurity::Plain => {
AsyncSmtpTransport::<Tokio1Executor>::builder_dangerous(self.host.clone())
}
};
builder = builder.port(self.port);
if let Some(ct) = self.connection_timeout {
builder = builder.timeout(Some(ct));
}
if let (Some(u), Some(p)) = (&self.username, &self.password) {
builder = builder
.credentials(Credentials::new(u.clone(), p.clone()))
.authentication(vec![Mechanism::Plain]);
}
debug!(
host = %self.host,
port = self.port,
has_credentials = self.username.is_some() && self.password.is_some(),
timeout_ms = self.connection_timeout.map(|d| d.as_millis() as u64).unwrap_or(0),
"smtp transport builder configured"
);
Ok(EmailTransport {
inner: builder.build(),
})
}
}
fn to_mailbox(addr: &EmailAddress) -> Result<Mailbox, EmailError> {
let parsed: Address = addr.address.parse()?;
let mb = match &addr.name {
Some(name) if !name.is_empty() => Mailbox::new(Some(name.clone()), parsed),
_ => Mailbox::new(None, parsed),
};
Ok(mb)
}
pub fn build_message(
req: &SendEmailRequest,
from: Mailbox,
max_attachment_bytes: usize,
) -> Result<Message, EmailError> {
let has_text = req.text.as_deref().is_some_and(|s| !s.is_empty());
let has_html = req.html.as_deref().is_some_and(|s| !s.is_empty());
let recipient_count = req.to.len() + req.cc.len() + req.bcc.len();
debug!(
subject_len = req.subject.len(),
recipients = recipient_count,
attachments = req.attachments.len(),
has_text,
has_html,
"building email message"
);
if !has_text && !has_html {
return Err(EmailError::Missing(
"email body requires text or html".into(),
));
}
let mut builder = MessageBuilder::new()
.from(from)
.subject(req.subject.clone());
for addr in &req.to {
let mb = to_mailbox(addr)?;
builder = builder.to(mb);
}
for addr in &req.cc {
let mb = to_mailbox(addr)?;
builder = builder.cc(mb);
}
for addr in &req.bcc {
let mb = to_mailbox(addr)?;
builder = builder.bcc(mb);
}
if let Some(reply) = &req.reply_to {
let mb = to_mailbox(reply)?;
builder = builder.reply_to(mb);
}
let body_part: MultiPart = match (has_text, has_html) {
(true, true) => {
let text = SinglePart::plain(req.text.as_deref().unwrap_or_default().to_string());
let html = SinglePart::html(req.html.as_deref().unwrap_or_default().to_string());
MultiPart::alternative().singlepart(text).singlepart(html)
}
(true, false) => MultiPart::alternative().singlepart(SinglePart::plain(
req.text.as_deref().unwrap_or_default().to_string(),
)),
(false, true) => MultiPart::alternative().singlepart(SinglePart::html(
req.html.as_deref().unwrap_or_default().to_string(),
)),
(false, false) => unreachable!(),
};
let message = if req.attachments.is_empty() {
builder.multipart(body_part)?
} else {
let mut mixed = MultiPart::mixed().multipart(body_part);
for att in &req.attachments {
// base64 解码前先估算解压后大小，避免超大请求先吃满内存才被拒。
let estimated = att.data_b64.len() / 4 * 3;
if estimated > max_attachment_bytes {
return Err(EmailError::AttachmentTooLarge {
actual: estimated,
max: max_attachment_bytes,
});
}
let bytes =
base64::engine::general_purpose::STANDARD.decode(att.data_b64.as_bytes())?;
if bytes.len() > max_attachment_bytes {
return Err(EmailError::AttachmentTooLarge {
actual: bytes.len(),
max: max_attachment_bytes,
});
}
let ct_str = if att.content_type.is_empty() {
"application/octet-stream".to_string()
} else {
att.content_type.clone()
};
let content_type: ContentType =
ct_str
.parse()
.map_err(|e: lettre::message::header::ContentTypeErr| {
EmailError::Other(format!("invalid content_type {ct_str:?}: {e}"))
})?;
if let Some(cid) = &att.content_id {
mixed = mixed.singlepart(
LettreAttachment::new_inline_with_name(cid.clone(), att.filename.clone())
.body(bytes, content_type),
);
} else {
mixed = mixed.singlepart(
LettreAttachment::new(att.filename.clone()).body(bytes, content_type),
);
}
}
builder.multipart(mixed)?
};
Ok(message)
}