Deuxfleurs/aerogramme
15
0
Fork 1
Code Issues 33 Pull requests 1 Projects 11 Releases 5 Wiki Activity

Rename MailIdent to UniqueIdent and use those to identify mailboxes

Browse source
This commit is contained in:
Alex 2022-06-29 15:52:09 +02:00
parent b95028f89e
commit d737e33b5a
Signed by: lx
GPG key ID: 0E496D15096376BE
7 changed files with 76 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/imap/mailbox_view.rs
View file

@ -8,7 +8,7 @@ use imap_codec::types::flag::Flag;
use imap_codec::types::mailbox::{ListMailbox, Mailbox as MailboxCodec};
use imap_codec::types::response::{Code, Data, Status};
use crate::mail::mailbox::{Mailbox, Summary};
use crate::mail::mailbox::Mailbox;
use crate::mail::uidindex::UidIndex;
const DEFAULT_FLAGS: [Flag; 5] = [
@ -35,6 +35,7 @@ impl MailboxView {
/// Creates a new IMAP view into a mailbox.
/// Generates the necessary IMAP messages so that the client
/// has a satisfactory summary of the current mailbox's state.
/// These are the messages that are sent in response to a SELECT command.
pub async fn new(mailbox: Arc<Mailbox>) -> Result<(Self, Vec<Body>)> {
let state = mailbox.current_uid_index().await;
@ -140,7 +141,11 @@ impl MailboxView {
})
.flatten()
.collect();
flags.extend_from_slice(&DEFAULT_FLAGS);
for f in DEFAULT_FLAGS.iter() {
if !flags.contains(f) {
flags.push(f.clone());
}
}
let mut ret = vec![Body::Data(Data::Flags(flags.clone()))];
flags.push(Flag::Permanent);

2
src/lmtp.rs
View file

@ -20,7 +20,7 @@ use smtp_server::{reply, Config, ConnectionMetadata, Decision, MailMetadata};
use crate::config::*;
use crate::cryptoblob::*;
use crate::login::*;
use crate::mail::mail_ident::*;
use crate::mail::unique_ident::*;
pub struct LmtpServer {
bind_addr: SocketAddr,

46
src/mail/mailbox.rs
View file

@ -8,53 +8,40 @@ use tokio::sync::RwLock;
use crate::bayou::Bayou;
use crate::cryptoblob::Key;
use crate::login::Credentials;
use crate::mail::mail_ident::*;
use crate::mail::uidindex::*;
use crate::mail::unique_ident::*;
use crate::mail::IMF;
pub struct Summary {
pub validity: ImapUidvalidity,
pub next: ImapUid,
pub exists: u32,
pub recent: u32,
pub flags: Vec<String>,
pub unseen: Option<ImapUid>,
pub struct Mailbox {
id: UniqueIdent,
mbox: RwLock<MailboxInternal>,
}
impl std::fmt::Display for Summary {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(
f,
"uidvalidity: {}, uidnext: {}, exists: {}",
self.validity, self.next, self.exists
)
}
}
pub struct Mailbox(RwLock<MailboxInternal>);
impl Mailbox {
pub(super) async fn open(creds: &Credentials, name: &str) -> Result<Self> {
let index_path = format!("index/{}", name);
let mail_path = format!("mail/{}", name);
pub(super) async fn open(creds: &Credentials, id: UniqueIdent) -> Result<Self> {
let index_path = format!("index/{}", id);
let mail_path = format!("mail/{}", id);
let mut uid_index = Bayou::<UidIndex>::new(creds, index_path)?;
uid_index.sync().await?;
Ok(Self(RwLock::new(MailboxInternal {
let mbox = RwLock::new(MailboxInternal {
id,
bucket: creds.bucket().to_string(),
key: creds.keys.master.clone(),
encryption_key: creds.keys.master.clone(),
k2v: creds.k2v_client()?,
s3: creds.s3_client()?,
uid_index,
mail_path,
})))
});
Ok(Self { id, mbox })
}
/// Get a clone of the current UID Index of this mailbox
/// (cloning is cheap so don't hesitate to use this)
pub async fn current_uid_index(&self) -> UidIndex {
self.0.read().await.uid_index.state().clone()
self.mbox.read().await.uid_index.state().clone()
}
/// Insert an email in the mailbox
@ -91,14 +78,15 @@ impl Mailbox {
// Non standard but common flags:
// https://www.iana.org/assignments/imap-jmap-keywords/imap-jmap-keywords.xhtml
struct MailboxInternal {
id: UniqueIdent,
bucket: String,
key: Key,
mail_path: String,
encryption_key: Key,
k2v: K2vClient,
s3: S3Client,
uid_index: Bayou<UidIndex>,
mail_path: String,
}
impl MailboxInternal {

4
src/mail/mod.rs
View file

@ -1,6 +1,6 @@
pub mod mail_ident;
pub mod mailbox;
pub mod uidindex;
pub mod unique_ident;
pub mod user;
use std::convert::TryFrom;
@ -12,8 +12,8 @@ use rusoto_s3::S3Client;
use crate::bayou::Bayou;
use crate::cryptoblob::Key;
use crate::login::Credentials;
use crate::mail::mail_ident::*;
use crate::mail::uidindex::*;
use crate::mail::unique_ident::*;
// Internet Message Format
// aka RFC 822 - RFC 2822 - RFC 5322

42
src/mail/uidindex.rs
View file

@ -4,7 +4,7 @@ use im::{HashMap, OrdMap, OrdSet};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use crate::bayou::*;
use crate::mail::mail_ident::MailIdent;
use crate::mail::unique_ident::UniqueIdent;
pub type ImapUid = NonZeroU32;
pub type ImapUidvalidity = NonZeroU32;
@ -18,10 +18,10 @@ pub type Flag = String;
#[derive(Clone)]
pub struct UidIndex {
// Source of trust
pub table: OrdMap<MailIdent, (ImapUid, Vec<Flag>)>,
pub table: OrdMap<UniqueIdent, (ImapUid, Vec<Flag>)>,
// Indexes optimized for queries
pub idx_by_uid: OrdMap<ImapUid, MailIdent>,
pub idx_by_uid: OrdMap<ImapUid, UniqueIdent>,
pub idx_by_flag: FlagIndex,
// Counters
@ -32,36 +32,36 @@ pub struct UidIndex {
#[derive(Clone, Serialize, Deserialize, Debug)]
pub enum UidIndexOp {
MailAdd(MailIdent, ImapUid, Vec<Flag>),
MailDel(MailIdent),
FlagAdd(MailIdent, Vec<Flag>),
FlagDel(MailIdent, Vec<Flag>),
MailAdd(UniqueIdent, ImapUid, Vec<Flag>),
MailDel(UniqueIdent),
FlagAdd(UniqueIdent, Vec<Flag>),
FlagDel(UniqueIdent, Vec<Flag>),
}
impl UidIndex {
#[must_use]
pub fn op_mail_add(&self, ident: MailIdent, flags: Vec<Flag>) -> UidIndexOp {
pub fn op_mail_add(&self, ident: UniqueIdent, flags: Vec<Flag>) -> UidIndexOp {
UidIndexOp::MailAdd(ident, self.internalseq, flags)
}
#[must_use]
pub fn op_mail_del(&self, ident: MailIdent) -> UidIndexOp {
pub fn op_mail_del(&self, ident: UniqueIdent) -> UidIndexOp {
UidIndexOp::MailDel(ident)
}
#[must_use]
pub fn op_flag_add(&self, ident: MailIdent, flags: Vec<Flag>) -> UidIndexOp {
pub fn op_flag_add(&self, ident: UniqueIdent, flags: Vec<Flag>) -> UidIndexOp {
UidIndexOp::FlagAdd(ident, flags)
}
#[must_use]
pub fn op_flag_del(&self, ident: MailIdent, flags: Vec<Flag>) -> UidIndexOp {
pub fn op_flag_del(&self, ident: UniqueIdent, flags: Vec<Flag>) -> UidIndexOp {
UidIndexOp::FlagDel(ident, flags)
}
// INTERNAL functions to keep state consistent
fn reg_email(&mut self, ident: MailIdent, uid: ImapUid, flags: &Vec<Flag>) {
fn reg_email(&mut self, ident: UniqueIdent, uid: ImapUid, flags: &Vec<Flag>) {
// Insert the email in our table
self.table.insert(ident, (uid, flags.clone()));
@ -70,7 +70,7 @@ impl UidIndex {
self.idx_by_flag.insert(uid, flags);
}
fn unreg_email(&mut self, ident: &MailIdent) {
fn unreg_email(&mut self, ident: &UniqueIdent) {
// We do nothing if the mail does not exist
let (uid, flags) = match self.table.get(ident) {
Some(v) => v,
@ -198,7 +198,7 @@ impl FlagIndex {
#[derive(Serialize, Deserialize)]
struct UidIndexSerializedRepr {
mails: Vec<(ImapUid, MailIdent, Vec<Flag>)>,
mails: Vec<(ImapUid, UniqueIdent, Vec<Flag>)>,
uidvalidity: ImapUidvalidity,
uidnext: ImapUid,
internalseq: ImapUid,
@ -261,7 +261,7 @@ mod tests {
// Add message 1
{
let m = MailIdent([0x01; 24]);
let m = UniqueIdent([0x01; 24]);
let f = vec!["\\Recent".to_string(), "\\Archive".to_string()];
let ev = state.op_mail_add(m, f);
state = state.apply(&ev);
@ -282,7 +282,7 @@ mod tests {
// Add message 2
{
let m = MailIdent([0x02; 24]);
let m = UniqueIdent([0x02; 24]);
let f = vec!["\\Seen".to_string(), "\\Archive".to_string()];
let ev = state.op_mail_add(m, f);
state = state.apply(&ev);
@ -293,7 +293,7 @@ mod tests {
// Add flags to message 1
{
let m = MailIdent([0x01; 24]);
let m = UniqueIdent([0x01; 24]);
let f = vec!["Important".to_string(), "$cl_1".to_string()];
let ev = state.op_flag_add(m, f);
state = state.apply(&ev);
@ -301,7 +301,7 @@ mod tests {
// Delete flags from message 1
{
let m = MailIdent([0x01; 24]);
let m = UniqueIdent([0x01; 24]);
let f = vec!["\\Recent".to_string()];
let ev = state.op_flag_del(m, f);
state = state.apply(&ev);
@ -312,7 +312,7 @@ mod tests {
// Delete message 2
{
let m = MailIdent([0x02; 24]);
let m = UniqueIdent([0x02; 24]);
let ev = state.op_mail_del(m);
state = state.apply(&ev);
@ -322,7 +322,7 @@ mod tests {
// Add a message 3 concurrent to message 1 (trigger a uid validity change)
{
let m = MailIdent([0x03; 24]);
let m = UniqueIdent([0x03; 24]);
let f = vec!["\\Archive".to_string(), "\\Recent".to_string()];
let ev = UidIndexOp::MailAdd(m, 1, f);
state = state.apply(&ev);
@ -334,7 +334,7 @@ mod tests {
assert!(state.uidvalidity > 1);
let (last_uid, ident) = state.idx_by_uid.get_max().unwrap();
assert_eq!(ident, &MailIdent([0x03; 24]));
assert_eq!(ident, &UniqueIdent([0x03; 24]));
let archive = state.idx_by_flag.0.get("\\Archive").unwrap();
assert_eq!(archive.len(), 2);

26
src/mail/mail_ident.rs → src/mail/unique_ident.rs
View file

@ -17,7 +17,7 @@ use crate::time::now_msec;
/// Their main property is to be unique without having to rely
/// on synchronization between IMAP processes.
#[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash, Debug)]
pub struct MailIdent(pub [u8; 24]);
pub struct UniqueIdent(pub [u8; 24]);
struct IdentGenerator {
pid: u128,
@ -34,12 +34,12 @@ impl IdentGenerator {
}
}
fn gen(&self) -> MailIdent {
fn gen(&self) -> UniqueIdent {
let sn = self.sn.fetch_add(1, Ordering::Relaxed);
let mut res = [0u8; 24];
res[0..16].copy_from_slice(&u128::to_be_bytes(self.pid));
res[16..24].copy_from_slice(&u64::to_be_bytes(sn));
MailIdent(res)
UniqueIdent(res)
}
}
@ -47,23 +47,23 @@ lazy_static! {
static ref GENERATOR: IdentGenerator = IdentGenerator::new();
}
pub fn gen_ident() -> MailIdent {
pub fn gen_ident() -> UniqueIdent {
GENERATOR.gen()
}
// -- serde --
impl<'de> Deserialize<'de> for MailIdent {
impl<'de> Deserialize<'de> for UniqueIdent {
fn deserialize<D>(d: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let v = String::deserialize(d)?;
MailIdent::from_str(&v).map_err(D::Error::custom)
UniqueIdent::from_str(&v).map_err(D::Error::custom)
}
}
impl Serialize for MailIdent {
impl Serialize for UniqueIdent {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
@ -72,16 +72,16 @@ impl Serialize for MailIdent {
}
}
impl ToString for MailIdent {
fn to_string(&self) -> String {
hex::encode(self.0)
impl std::fmt::Display for UniqueIdent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", hex::encode(self.0))
}
}
impl FromStr for MailIdent {
impl FromStr for UniqueIdent {
type Err = &'static str;
fn from_str(s: &str) -> Result<MailIdent, &'static str> {
fn from_str(s: &str) -> Result<UniqueIdent, &'static str> {
let bytes = hex::decode(s).map_err(|_| "invalid hex")?;
if bytes.len() != 24 {
@ -90,6 +90,6 @@ impl FromStr for MailIdent {
let mut tmp = [0u8; 24];
tmp[..].copy_from_slice(&bytes);
Ok(MailIdent(tmp))
Ok(UniqueIdent(tmp))
}
}

21
src/mail/user.rs
View file

@ -9,6 +9,7 @@ use rusoto_s3::S3Client;
use crate::login::{Credentials, StorageCredentials};
use crate::mail::mailbox::Mailbox;
use crate::mail::unique_ident::UniqueIdent;
pub struct User {
pub username: String,
@ -36,21 +37,29 @@ impl User {
/// Opens an existing mailbox given its IMAP name.
pub async fn open_mailbox(&self, name: &str) -> Result<Option<Arc<Mailbox>>> {
// TODO: handle mailbox names, mappings, renaming, etc
let id = match name {
"INBOX" => UniqueIdent([0u8; 24]),
_ => panic!("Only INBOX exists for now"),
};
let cache_key = (self.creds.storage.clone(), id);
{
let cache = MAILBOX_CACHE.cache.lock().unwrap();
if let Some(mb) = cache.get(&self.creds.storage).and_then(Weak::upgrade) {
if let Some(mb) = cache.get(&cache_key).and_then(Weak::upgrade) {
return Ok(Some(mb));
}
}
let mb = Arc::new(Mailbox::open(&self.creds, name).await?);
let mb = Arc::new(Mailbox::open(&self.creds, id).await?);
let mut cache = MAILBOX_CACHE.cache.lock().unwrap();
if let Some(concurrent_mb) = cache.get(&self.creds.storage).and_then(Weak::upgrade) {
drop(mb); // we worked for nothing but at least we didn't starve someone else
if let Some(concurrent_mb) = cache.get(&cache_key).and_then(Weak::upgrade) {
drop(mb); // we worked for nothing but at least we didn't starve someone else
Ok(Some(concurrent_mb))
} else {
cache.insert(self.creds.storage.clone(), Arc::downgrade(&mb));
cache.insert(cache_key, Arc::downgrade(&mb));
Ok(Some(mb))
}
}
@ -74,7 +83,7 @@ impl User {
// ---- Mailbox cache ----
struct MailboxCache {
cache: std::sync::Mutex<HashMap<StorageCredentials, Weak<Mailbox>>>,
cache: std::sync::Mutex<HashMap<(StorageCredentials, UniqueIdent), Weak<Mailbox>>>,
}
impl MailboxCache {