🐝
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

273 lines
7.1 KiB

/*
* meli - backends module
*
* Copyright 2017 Manos Pitsidianakis
*
* This file is part of meli.
*
* meli is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* meli is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with meli. If not, see <http://www.gnu.org/licenses/>.
*/
pub mod imap;
pub mod maildir;
pub mod mbox;
use crate::async_workers::*;
use crate::conf::AccountSettings;
use crate::error::Result;
//use mailbox::backends::imap::ImapType;
//use mailbox::backends::mbox::MboxType;
use self::maildir::MaildirType;
use super::email::{Envelope, EnvelopeHash, Flag};
use std::fmt;
use std::fmt::Debug;
use std::ops::Deref;
use fnv::FnvHashMap;
use std;
pub type BackendCreator = Box<Fn(&AccountSettings) -> Box<MailBackend>>;
/// A hashmap containing all available mail backends.
/// An abstraction over any available backends.
pub struct Backends {
map: FnvHashMap<std::string::String, Box<Fn() -> BackendCreator>>,
}
impl Default for Backends {
fn default() -> Self {
Backends::new()
}
}
impl Backends {
pub fn new() -> Self {
let mut b = Backends {
map: FnvHashMap::with_capacity_and_hasher(1, Default::default()),
};
b.register(
"maildir".to_string(),
Box::new(|| Box::new(|f| Box::new(MaildirType::new(f)))),
);
//b.register("mbox".to_string(), Box::new(|| Box::new(MboxType::new(""))));
//b.register("imap".to_string(), Box::new(|| Box::new(ImapType::new(""))));
b
}
pub fn get(&self, key: &str) -> BackendCreator {
if !self.map.contains_key(key) {
panic!("{} is not a valid mail backend", key);
}
self.map[key]()
}
pub fn register(&mut self, key: String, backend: Box<Fn() -> BackendCreator>) {
if self.map.contains_key(&key) {
panic!("{} is an already registered backend", key);
}
self.map.insert(key, backend);
}
}
#[derive(Debug)]
pub enum RefreshEventKind {
Update(EnvelopeHash, Box<Envelope>),
/// Rename(old_hash, new_hash)
Rename(EnvelopeHash, EnvelopeHash),
Create(Box<Envelope>),
Remove(FolderHash),
Rescan,
}
#[derive(Debug)]
pub struct RefreshEvent {
hash: FolderHash,
kind: RefreshEventKind,
}
impl RefreshEvent {
pub fn hash(&self) -> FolderHash {
self.hash
}
pub fn kind(self) -> RefreshEventKind {
/* consumes self! */
self.kind
}
}
/// A `RefreshEventConsumer` is a boxed closure that must be used to consume a `RefreshEvent` and
/// send it to a UI provided channel. We need this level of abstraction to provide an interface for
/// all users of mailbox refresh events.
pub struct RefreshEventConsumer(Box<Fn(RefreshEvent) -> ()>);
unsafe impl Send for RefreshEventConsumer {}
unsafe impl Sync for RefreshEventConsumer {}
impl RefreshEventConsumer {
pub fn new(b: Box<Fn(RefreshEvent) -> ()>) -> Self {
RefreshEventConsumer(b)
}
pub fn send(&self, r: RefreshEvent) {
self.0(r);
}
}
pub struct NotifyFn(Box<Fn(FolderHash) -> ()>);
unsafe impl Send for NotifyFn {}
unsafe impl Sync for NotifyFn {}
impl fmt::Debug for NotifyFn {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "NotifyFn Box")
}
}
impl From<Box<Fn(FolderHash) -> ()>> for NotifyFn {
fn from(kind: Box<Fn(FolderHash) -> ()>) -> Self {
NotifyFn(kind)
}
}
impl NotifyFn {
pub fn new(b: Box<Fn(FolderHash) -> ()>) -> Self {
NotifyFn(b)
}
pub fn notify(&self, f: FolderHash) {
self.0(f);
}
}
pub trait MailBackend: ::std::fmt::Debug {
fn get(&mut self, folder: &Folder) -> Async<Result<Vec<Envelope>>>;
fn watch(&self, sender: RefreshEventConsumer) -> Result<()>;
fn folders(&self) -> FnvHashMap<FolderHash, Folder>;
fn operation(&self, hash: EnvelopeHash, folder_hash: FolderHash) -> Box<BackendOp>;
fn save(&self, bytes: &[u8], folder: &str) -> Result<()>;
//login function
}
/// A `BackendOp` manages common operations for the various mail backends. They only live for the
/// duration of the operation. They are generated by the `operation` method of `Mailbackend` trait.
///
/// # Motivation
///
/// We need a way to do various operations on individual mails regardless of what backend they come
/// from (eg local or imap).
///
/// # Creation
/// ```no_run
/// /* Create operation from Backend */
///
/// let op = backend.operation(message.hash(), mailbox.folder.hash());
/// ```
///
/// # Example
/// ```
/// use melib::mailbox::backends::{BackendOp};
/// use melib::Result;
/// use melib::{Envelope, Flag};
///
/// #[derive(Debug)]
/// struct FooOp {}
///
/// impl BackendOp for FooOp {
/// fn description(&self) -> String {
/// "Foobar".to_string()
/// }
/// fn as_bytes(&mut self) -> Result<&[u8]> {
/// unimplemented!()
/// }
/// fn fetch_headers(&mut self) -> Result<&[u8]> {
/// unimplemented!()
/// }
/// fn fetch_body(&mut self) -> Result<&[u8]> {
/// unimplemented!()
/// }
/// fn fetch_flags(&self) -> Flag {
/// unimplemented!()
/// }
/// }
///
/// let operation = Box::new(FooOp {});
/// assert_eq!("Foobar", &operation.description());
/// ```
pub trait BackendOp: ::std::fmt::Debug + ::std::marker::Send {
fn description(&self) -> String;
fn as_bytes(&mut self) -> Result<&[u8]>;
//fn delete(&self) -> ();
//fn copy(&self
fn fetch_headers(&mut self) -> Result<&[u8]>;
fn fetch_body(&mut self) -> Result<&[u8]>;
fn fetch_flags(&self) -> Flag;
fn set_flag(&mut self, envelope: &mut Envelope, flag: Flag) -> Result<()>;
}
}
}
pub trait BackendFolder: Debug {
fn hash(&self) -> FolderHash;
fn name(&self) -> &str;
fn change_name(&mut self, new_name: &str);
fn clone(&self) -> Folder;
fn children(&self) -> &Vec<FolderHash>;
fn parent(&self) -> Option<FolderHash>;
}
#[derive(Debug)]
struct DummyFolder {
v: Vec<FolderHash>,
}
impl BackendFolder for DummyFolder {
fn hash(&self) -> FolderHash {
0
}
fn name(&self) -> &str {
""
}
fn change_name(&mut self, _s: &str) {}
fn clone(&self) -> Folder {
folder_default()
}
fn children(&self) -> &Vec<FolderHash> {
&self.v
}
fn parent(&self) -> Option<FolderHash> {
None
}
}
pub fn folder_default() -> Folder {
Box::new(DummyFolder {
v: Vec::with_capacity(0),
})
}
pub type FolderHash = u64;
pub type Folder = Box<dyn BackendFolder + Send>;
impl Clone for Folder {
fn clone(&self) -> Self {
BackendFolder::clone(self.deref())
}
}
impl Default for Folder {
fn default() -> Self {
folder_default()
}
}