aerogramme/aero-collections/src/user.rs

312 lines
10 KiB
Rust
Raw Normal View History

2024-03-08 07:43:28 +00:00
use std::collections::HashMap;
use std::sync::{Arc, Weak};
2022-06-30 12:17:54 +00:00
use anyhow::{anyhow, bail, Result};
use lazy_static::lazy_static;
2022-06-30 12:02:57 +00:00
use tokio::sync::watch;
2022-06-29 11:16:58 +00:00
2024-03-08 07:43:28 +00:00
use aero_user::cryptoblob::{open_deserialize, seal_serialize};
use aero_user::login::Credentials;
use aero_user::storage;
use crate::mail::incoming::incoming_mail_watch_process;
2022-06-29 11:16:58 +00:00
use crate::mail::mailbox::Mailbox;
use crate::mail::uidindex::ImapUidvalidity;
2024-03-08 07:43:28 +00:00
use crate::mail::unique_ident::UniqueIdent;
2024-02-27 17:33:49 +00:00
use crate::mail::namespace::{MAILBOX_HIERARCHY_DELIMITER, INBOX, DRAFTS, ARCHIVE, SENT, TRASH, MAILBOX_LIST_PK, MAILBOX_LIST_SK,MailboxList,CreatedMailbox};
//@FIXME User should be totally rewriten
//to extract the local mailbox list
//to the mail/namespace.rs file (and mailbox list should be reworded as mail namespace)
2022-06-30 12:02:57 +00:00
pub struct User {
2022-06-29 11:16:58 +00:00
pub username: String,
pub creds: Credentials,
2023-12-18 16:09:44 +00:00
pub storage: storage::Store,
2022-06-30 12:02:57 +00:00
pub mailboxes: std::sync::Mutex<HashMap<UniqueIdent, Weak<Mailbox>>>,
tx_inbox_id: watch::Sender<Option<(UniqueIdent, ImapUidvalidity)>>,
2022-06-29 11:16:58 +00:00
}
impl User {
2022-06-30 12:02:57 +00:00
pub async fn new(username: String, creds: Credentials) -> Result<Arc<Self>> {
2023-12-18 16:09:44 +00:00
let cache_key = (username.clone(), creds.storage.unique());
2022-06-30 12:02:57 +00:00
{
let cache = USER_CACHE.lock().unwrap();
if let Some(u) = cache.get(&cache_key).and_then(Weak::upgrade) {
return Ok(u);
}
}
let user = Self::open(username, creds).await?;
let mut cache = USER_CACHE.lock().unwrap();
if let Some(concurrent_user) = cache.get(&cache_key).and_then(Weak::upgrade) {
drop(user);
Ok(concurrent_user)
} else {
cache.insert(cache_key, Arc::downgrade(&user));
Ok(user)
}
2022-06-29 11:16:58 +00:00
}
2022-06-29 11:41:05 +00:00
/// Lists user's available mailboxes
pub async fn list_mailboxes(&self) -> Result<Vec<String>> {
let (list, _ct) = self.load_mailbox_list().await?;
2022-07-12 13:23:30 +00:00
Ok(list.existing_mailbox_names())
2022-06-29 11:41:05 +00:00
}
/// Opens an existing mailbox given its IMAP name.
pub async fn open_mailbox(&self, name: &str) -> Result<Option<Arc<Mailbox>>> {
let (mut list, ct) = self.load_mailbox_list().await?;
//@FIXME it could be a trace or an opentelemtry trace thing.
// Be careful to not leak sensible data
/*
2022-07-12 13:59:13 +00:00
eprintln!("List of mailboxes:");
for ent in list.0.iter() {
eprintln!(" - {:?}", ent);
}
*/
2022-07-12 13:23:30 +00:00
if let Some((uidvalidity, Some(mbid))) = list.get_mailbox(name) {
2022-07-21 10:50:44 +00:00
let mb = self.open_mailbox_by_id(mbid, uidvalidity).await?;
let mb_uidvalidity = mb.current_uid_index().await.uidvalidity;
if mb_uidvalidity > uidvalidity {
list.update_uidvalidity(name, mb_uidvalidity);
2023-12-18 16:09:44 +00:00
self.save_mailbox_list(&list, ct).await?;
}
2022-07-21 10:50:44 +00:00
Ok(Some(mb))
2022-07-12 13:23:30 +00:00
} else {
2022-07-21 10:50:44 +00:00
Ok(None)
}
}
2022-07-12 13:59:13 +00:00
/// Check whether mailbox exists
pub async fn has_mailbox(&self, name: &str) -> Result<bool> {
let (list, _ct) = self.load_mailbox_list().await?;
Ok(list.has_mailbox(name))
}
/// Creates a new mailbox in the user's IMAP namespace.
2022-06-30 12:17:54 +00:00
pub async fn create_mailbox(&self, name: &str) -> Result<()> {
2022-07-12 13:23:30 +00:00
if name.ends_with(MAILBOX_HIERARCHY_DELIMITER) {
bail!("Invalid mailbox name: {}", name);
}
2022-06-30 12:17:54 +00:00
let (mut list, ct) = self.load_mailbox_list().await?;
2022-07-12 13:23:30 +00:00
match list.create_mailbox(name) {
CreatedMailbox::Created(_, _) => {
2023-12-18 16:09:44 +00:00
self.save_mailbox_list(&list, ct).await?;
2022-07-12 13:23:30 +00:00
Ok(())
}
2022-06-30 12:17:54 +00:00
CreatedMailbox::Existed(_, _) => Err(anyhow!("Mailbox {} already exists", name)),
}
}
/// Deletes a mailbox in the user's IMAP namespace.
2022-07-12 13:23:30 +00:00
pub async fn delete_mailbox(&self, name: &str) -> Result<()> {
if name == INBOX {
bail!("Cannot delete INBOX");
}
let (mut list, ct) = self.load_mailbox_list().await?;
if list.has_mailbox(name) {
2024-01-19 15:47:20 +00:00
//@TODO: actually delete mailbox contents
2022-07-12 13:23:30 +00:00
list.set_mailbox(name, None);
2023-12-18 16:09:44 +00:00
self.save_mailbox_list(&list, ct).await?;
2022-07-12 13:23:30 +00:00
Ok(())
} else {
bail!("Mailbox {} does not exist", name);
}
}
/// Renames a mailbox in the user's IMAP namespace.
2022-07-12 11:19:27 +00:00
pub async fn rename_mailbox(&self, old_name: &str, new_name: &str) -> Result<()> {
2022-07-12 13:23:30 +00:00
let (mut list, ct) = self.load_mailbox_list().await?;
if old_name.ends_with(MAILBOX_HIERARCHY_DELIMITER) {
bail!("Invalid mailbox name: {}", old_name);
}
if new_name.ends_with(MAILBOX_HIERARCHY_DELIMITER) {
bail!("Invalid mailbox name: {}", new_name);
}
2022-07-12 11:19:27 +00:00
if old_name == INBOX {
2022-07-12 13:23:30 +00:00
list.rename_mailbox(old_name, new_name)?;
if !self.ensure_inbox_exists(&mut list, &ct).await? {
2023-12-18 16:09:44 +00:00
self.save_mailbox_list(&list, ct).await?;
2022-07-12 13:23:30 +00:00
}
2022-07-12 11:19:27 +00:00
} else {
2022-07-12 13:23:30 +00:00
let names = list.existing_mailbox_names();
let old_name_w_delim = format!("{}{}", old_name, MAILBOX_HIERARCHY_DELIMITER);
let new_name_w_delim = format!("{}{}", new_name, MAILBOX_HIERARCHY_DELIMITER);
if names
.iter()
.any(|x| x == new_name || x.starts_with(&new_name_w_delim))
{
bail!("Mailbox {} already exists", new_name);
}
for name in names.iter() {
if name == old_name {
list.rename_mailbox(name, new_name)?;
} else if let Some(tail) = name.strip_prefix(&old_name_w_delim) {
let nnew = format!("{}{}", new_name_w_delim, tail);
list.rename_mailbox(name, &nnew)?;
}
}
2023-11-17 09:46:13 +00:00
2023-12-18 16:09:44 +00:00
self.save_mailbox_list(&list, ct).await?;
2022-07-12 11:19:27 +00:00
}
2022-07-12 13:23:30 +00:00
Ok(())
}
2022-06-30 12:02:57 +00:00
// ---- Internal user & mailbox management ----
2022-06-30 12:17:54 +00:00
2022-06-30 12:02:57 +00:00
async fn open(username: String, creds: Credentials) -> Result<Arc<Self>> {
2023-12-21 20:54:36 +00:00
let storage = creds.storage.build().await?;
2022-06-30 12:02:57 +00:00
let (tx_inbox_id, rx_inbox_id) = watch::channel(None);
2022-06-30 12:02:57 +00:00
let user = Arc::new(Self {
username,
creds: creds.clone(),
2023-12-18 16:09:44 +00:00
storage,
2022-06-30 12:02:57 +00:00
tx_inbox_id,
mailboxes: std::sync::Mutex::new(HashMap::new()),
});
// Ensure INBOX exists (done inside load_mailbox_list)
user.load_mailbox_list().await?;
tokio::spawn(incoming_mail_watch_process(
Arc::downgrade(&user),
user.creds.clone(),
rx_inbox_id,
));
2022-06-30 14:18:08 +00:00
2022-06-30 12:02:57 +00:00
Ok(user)
}
pub(super) async fn open_mailbox_by_id(
2022-06-30 12:17:54 +00:00
&self,
id: UniqueIdent,
min_uidvalidity: ImapUidvalidity,
2022-07-21 10:50:44 +00:00
) -> Result<Arc<Mailbox>> {
{
2022-06-30 12:02:57 +00:00
let cache = self.mailboxes.lock().unwrap();
if let Some(mb) = cache.get(&id).and_then(Weak::upgrade) {
2022-07-21 10:50:44 +00:00
return Ok(mb);
}
}
let mb = Arc::new(Mailbox::open(&self.creds, id, min_uidvalidity).await?);
2022-06-30 12:02:57 +00:00
let mut cache = self.mailboxes.lock().unwrap();
if let Some(concurrent_mb) = cache.get(&id).and_then(Weak::upgrade) {
drop(mb); // we worked for nothing but at least we didn't starve someone else
2022-07-21 10:50:44 +00:00
Ok(concurrent_mb)
} else {
2022-06-30 12:02:57 +00:00
cache.insert(id, Arc::downgrade(&mb));
2022-07-21 10:50:44 +00:00
Ok(mb)
}
2022-06-29 11:41:05 +00:00
}
// ---- Mailbox list management ----
2023-11-02 11:58:45 +00:00
async fn load_mailbox_list(&self) -> Result<(MailboxList, Option<storage::RowRef>)> {
2023-12-18 16:09:44 +00:00
let row_ref = storage::RowRef::new(MAILBOX_LIST_PK, MAILBOX_LIST_SK);
2023-12-27 13:58:28 +00:00
let (mut list, row) = match self
.storage
.row_fetch(&storage::Selector::Single(&row_ref))
.await
{
2023-11-02 11:58:45 +00:00
Err(storage::StorageError::NotFound) => (MailboxList::new(), None),
Err(e) => return Err(e.into()),
2023-11-02 11:58:45 +00:00
Ok(rv) => {
2022-07-12 13:23:30 +00:00
let mut list = MailboxList::new();
2023-12-18 16:09:44 +00:00
let (row_ref, row_vals) = match rv.into_iter().next() {
Some(row_val) => (row_val.row_ref, row_val.value),
None => (row_ref, vec![]),
};
for v in row_vals {
2023-11-02 11:58:45 +00:00
if let storage::Alternative::Value(vbytes) = v {
let list2 =
open_deserialize::<MailboxList>(&vbytes, &self.creds.keys.master)?;
2022-07-12 13:23:30 +00:00
list.merge(list2);
2022-06-30 14:18:08 +00:00
}
}
2023-12-18 16:09:44 +00:00
(list, Some(row_ref))
}
};
2024-01-19 16:40:08 +00:00
let is_default_mbx_missing = [DRAFTS, ARCHIVE, SENT, TRASH]
2024-01-19 15:47:20 +00:00
.iter()
.map(|mbx| list.create_mailbox(mbx))
2024-01-19 16:40:08 +00:00
.fold(false, |acc, r| {
acc || matches!(r, CreatedMailbox::Created(..))
});
2024-01-19 15:47:20 +00:00
let is_inbox_missing = self.ensure_inbox_exists(&mut list, &row).await?;
if is_default_mbx_missing && !is_inbox_missing {
// It's the only case where we created some mailboxes and not saved them
// So we save them!
self.save_mailbox_list(&list, row.clone()).await?;
}
2022-07-12 11:19:27 +00:00
2023-11-02 11:58:45 +00:00
Ok((list, row))
2022-07-12 11:19:27 +00:00
}
async fn ensure_inbox_exists(
&self,
list: &mut MailboxList,
2023-11-02 11:58:45 +00:00
ct: &Option<storage::RowRef>,
2022-07-12 13:23:30 +00:00
) -> Result<bool> {
// If INBOX doesn't exist, create a new mailbox with that name
// and save new mailbox list.
2022-06-30 12:02:57 +00:00
// Also, ensure that the mpsc::watch that keeps track of the
// inbox id is up-to-date.
2022-07-12 13:23:30 +00:00
let saved;
let (inbox_id, inbox_uidvalidity) = match list.create_mailbox(INBOX) {
CreatedMailbox::Created(i, v) => {
2023-12-18 16:09:44 +00:00
self.save_mailbox_list(list, ct.clone()).await?;
2022-07-12 13:23:30 +00:00
saved = true;
(i, v)
}
CreatedMailbox::Existed(i, v) => {
saved = false;
(i, v)
}
};
2022-07-12 11:19:27 +00:00
let inbox_id = Some((inbox_id, inbox_uidvalidity));
if *self.tx_inbox_id.borrow() != inbox_id {
self.tx_inbox_id.send(inbox_id).unwrap();
}
2022-06-30 12:17:54 +00:00
2022-07-12 13:23:30 +00:00
Ok(saved)
2022-06-30 12:17:54 +00:00
}
async fn save_mailbox_list(
&self,
list: &MailboxList,
2023-12-18 16:09:44 +00:00
ct: Option<storage::RowRef>,
2022-06-30 12:17:54 +00:00
) -> Result<()> {
let list_blob = seal_serialize(list, &self.creds.keys.master)?;
2023-12-18 16:09:44 +00:00
let rref = ct.unwrap_or(storage::RowRef::new(MAILBOX_LIST_PK, MAILBOX_LIST_SK));
let row_val = storage::RowVal::new(rref, list_blob);
self.storage.row_insert(vec![row_val]).await?;
2022-06-30 12:17:54 +00:00
Ok(())
}
}
2022-06-29 11:41:05 +00:00
2022-06-30 12:02:57 +00:00
// ---- User cache ----
lazy_static! {
2023-12-18 16:09:44 +00:00
static ref USER_CACHE: std::sync::Mutex<HashMap<(String, storage::UnicityBuffer), Weak<User>>> =
2022-06-30 12:17:54 +00:00
std::sync::Mutex::new(HashMap::new());
}