full tokio support

Author: dignifiedquire

Cargo.toml

@@ -19,15 +19,16 @@ is-it-maintained-issue-resolution = { repository = "async-email/async-imap" }
 is-it-maintained-open-issues = { repository = "async-email/async-imap" }
 
 [features]
-default = []
+default = ["runtime-async-std"]
+
+runtime-async-std = ["async-std", "async-native-tls/runtime-async-std"]
+runtime-tokio = ["tokio", "async-native-tls/runtime-tokio"]
 
 [dependencies]
 imap-proto = "0.16.1"
 nom = "7.0"
 base64 = "0.13"
 chrono = "0.4"
-async-native-tls = { version = "0.3" }
-async-std = { version = "1.8.0", default-features = false, features = ["std"] }
 pin-utils = "0.1.0-alpha.4"
 futures = "0.3.15"
 ouroboros = "0.15"
@@ -36,30 +37,15 @@ byte-pool = "0.2.2"
 once_cell = "1.8.0"
 log = "0.4.8"
 thiserror = "1.0.9"
+async-channel = "1.6.1"
 
-[dev-dependencies]
-lettre_email = "0.9"
-pretty_assertions = "1.2"
-async-smtp = { version = "0.4" }
-async-std = { version = "1.8.0", default-features = false, features = ["std", "attributes"] }
-tokio = { version = "1", features = ["rt-multi-thread"] }
-
-[[example]]
-name = "basic"
-required-features = ["default"]
+async-native-tls = { version = "0.4", default-features = false }
+async-std = { version = "1.8.0", default-features = false, features = ["std"], optional = true }
+tokio = { version = "1", features = ["net", "sync", "time"], optional = true }
 
-[[example]]
-name = "gmail_oauth2"
-required-features = ["default"]
 
-[[example]]
-name = "futures"
-required-features = ["default"]
-
-[[example]]
-name = "tokio"
-required-features = ["default"]
+[dev-dependencies]
+pretty_assertions = "1.2"
+async-std = { version = "1.8.0", features = ["std", "attributes"] }
+tokio = { version = "1", features = ["rt-multi-thread", "macros"] }
 
-[[test]]
-name = "imap_integration"
-required-features = ["default"]

examples/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "async-imap-examples"
+version = "0.1.0"
+publish = false
+authors = ["dignifiedquire <[email protected]>"]
+license = "Apache-2.0/MIT"
+edition = "2018"
+
+[features]
+default = ["runtime-async-std"]
+
+runtime-async-std = ["async-std", "async-native-tls/runtime-async-std", "async-smtp/runtime-async-std", "async-imap/runtime-async-std"]
+runtime-tokio = ["tokio", "async-native-tls/runtime-tokio", "async-smtp/runtime-tokio", "async-imap/runtime-tokio"]
+
+[dependencies]
+async-imap = { path = "../", default-features = false }
+async-native-tls = { version = "0.4", default-features = false }
+async-smtp = { version = "0.4", default-features = false, features = ["smtp-transport"] }
+
+async-std = { version = "1.8.0", features = ["std", "attributes"], optional = true }
+futures = "0.3.21"
+tokio = { version = "1", features = ["rt-multi-thread", "macros"], optional = true }
+
+[patch.crates-io]
+async-smtp = { git = "https://github.com/async-email/async-smtp", branch = "tokio" }

examples/gmail_oauth2.rs

@@ -1,20 +1,20 @@
-use async_imap::error::{Error, Result};
-use async_std::prelude::*;
-use async_std::task;
 use std::env;
 
-fn main() -> Result<()> {
-    task::block_on(async {
-        let args: Vec<String> = env::args().collect();
-        if args.len() != 4 {
-            eprintln!("need three arguments: imap-server login password");
-            Err(Error::Bad("need three arguments".into()))
-        } else {
-            let res = fetch_inbox_top(&args[1], &args[2], &args[3]).await?;
-            println!("**result:\n{}", res.unwrap());
-            Ok(())
-        }
-    })
+use async_imap::error::{Error, Result};
+use futures::TryStreamExt;
+
+#[cfg_attr(feature = "runtime-tokio", tokio::main)]
+#[cfg_attr(feature = "runtime-async-std", async_std::main)]
+async fn main() -> Result<()> {
+    let args: Vec<String> = env::args().collect();
+    if args.len() != 4 {
+        eprintln!("need three arguments: imap-server login password");
+        Err(Error::Bad("need three arguments".into()))
+    } else {
+        let res = fetch_inbox_top(&args[1], &args[2], &args[3]).await?;
+        println!("**result:\n{}", res.unwrap());
+        Ok(())
+    }
 }
 
 async fn fetch_inbox_top(imap_server: &str, login: &str, password: &str) -> Result<Option<String>> {
@@ -38,7 +38,7 @@ async fn fetch_inbox_top(imap_server: &str, login: &str, password: &str) -> Resu
     // fetch message number 1 in this mailbox, along with its RFC822 field.
     // RFC 822 dictates the format of the body of e-mails
     let messages_stream = imap_session.fetch("1", "RFC822").await?;
-    let messages: Vec<_> = messages_stream.collect::<Result<_>>().await?;
+    let messages: Vec<_> = messages_stream.try_collect().await?;
     let message = if let Some(m) = messages.first() {
         m
     } else {

examples/basic.rs renamed to examples/src/bin/basic.rs

@@ -1,7 +1,8 @@
-use async_imap::error::{Error, Result};
-use async_std::prelude::*;
 use std::env;
 
+use async_imap::error::{Error, Result};
+use futures::TryStreamExt;
+
 fn main() -> Result<()> {
     futures::executor::block_on(async {
         let args: Vec<String> = env::args().collect();
@@ -36,7 +37,7 @@ async fn fetch_inbox_top(imap_server: &str, login: &str, password: &str) -> Resu
     // fetch message number 1 in this mailbox, along with its RFC822 field.
     // RFC 822 dictates the format of the body of e-mails
     let messages_stream = imap_session.fetch("1", "RFC822").await?;
-    let messages: Vec<_> = messages_stream.collect::<Result<_>>().await?;
+    let messages: Vec<_> = messages_stream.try_collect().await?;
     let message = if let Some(m) = messages.first() {
         m
     } else {

examples/futures.rs renamed to examples/src/bin/futures.rs

@@ -0,0 +1,62 @@
+use async_imap::error::Result;
+use futures::StreamExt;
+
+struct GmailOAuth2 {
+    user: String,
+    access_token: String,
+}
+
+impl async_imap::Authenticator for &GmailOAuth2 {
+    type Response = String;
+
+    fn process(&mut self, _data: &[u8]) -> Self::Response {
+        format!(
+            "user={}\x01auth=Bearer {}\x01\x01",
+            self.user, self.access_token
+        )
+    }
+}
+
+#[cfg_attr(feature = "runtime-tokio", tokio::main)]
+#[cfg_attr(feature = "runtime-async-std", async_std::main)]
+async fn main() -> Result<()> {
+    let gmail_auth = GmailOAuth2 {
+        user: String::from("[email protected]"),
+        access_token: String::from("<access_token>"),
+    };
+    let domain = "imap.gmail.com";
+    let port = 993;
+    let socket_addr = (domain, port);
+    let tls = async_native_tls::TlsConnector::new();
+    let client = async_imap::connect(socket_addr, domain, tls).await?;
+
+    let mut imap_session = match client.authenticate("XOAUTH2", &gmail_auth).await {
+        Ok(c) => c,
+        Err((e, _unauth_client)) => {
+            println!("error authenticating: {}", e);
+            return Err(e);
+        }
+    };
+
+    match imap_session.select("INBOX").await {
+        Ok(mailbox) => println!("{}", mailbox),
+        Err(e) => println!("Error selecting INBOX: {}", e),
+    };
+
+    {
+        let mut msgs = imap_session.fetch("2", "body[text]").await.map_err(|e| {
+            eprintln!("Error Fetching email 2: {}", e);
+            e
+        })?;
+
+        // TODO: get rid of this
+        let mut msgs = unsafe { std::pin::Pin::new_unchecked(&mut msgs) };
+
+        while let Some(msg) = msgs.next().await {
+            print!("{:?}", msg?);
+        }
+    }
+
+    imap_session.logout().await?;
+    Ok(())
+}

examples/src/bin/gmail_oauth2.rs

@@ -1,22 +1,27 @@
-use async_imap::error::{Error, Result};
-use async_std::prelude::*;
-// use async_std::io;
-use async_imap::extensions::idle::IdleResponse::*;
-use async_std::task;
 use std::env;
 use std::time::Duration;
 
-fn main() -> Result<()> {
-    task::block_on(async {
-        let args: Vec<String> = env::args().collect();
-        if args.len() != 4 {
-            eprintln!("need three arguments: imap-server login password");
-            Err(Error::Bad("need three arguments".into()))
-        } else {
-            fetch_and_idle(&args[1], &args[2], &args[3]).await?;
-            Ok(())
-        }
-    })
+use async_imap::error::{Error, Result};
+use async_imap::extensions::idle::IdleResponse::*;
+use futures::StreamExt;
+
+#[cfg(feature = "runtime-async-std")]
+use async_std::{task, task::sleep};
+
+#[cfg(feature = "runtime-tokio")]
+use tokio::{task, time::sleep};
+
+#[cfg_attr(feature = "runtime-tokio", tokio::main)]
+#[cfg_attr(feature = "runtime-async-std", async_std::main)]
+async fn main() -> Result<()> {
+    let args: Vec<String> = env::args().collect();
+    if args.len() != 4 {
+        eprintln!("need three arguments: imap-server login password");
+        Err(Error::Bad("need three arguments".into()))
+    } else {
+        fetch_and_idle(&args[1], &args[2], &args[3]).await?;
+        Ok(())
+    }
 }
 
 async fn fetch_and_idle(imap_server: &str, login: &str, password: &str) -> Result<()> {
@@ -59,7 +64,7 @@ async fn fetch_and_idle(imap_server: &str, login: &str, password: &str) -> Resul
 
     task::spawn(async move {
         println!("-- thread: waiting for 30s");
-        task::sleep(Duration::from_secs(30)).await;
+        sleep(Duration::from_secs(30)).await;
         println!("-- thread: waited 30 secs, now interrupting idle");
         drop(interrupt);
     });