start IMAP loops for all transports

Author: link2xt

src/configure.rs

@@ -529,12 +529,7 @@ async fn configure(ctx: &Context, param: &EnteredLoginParam) -> Result<Option<&'
 
     let transport_id = 0;
     let (_s, r) = async_channel::bounded(1);
-    let mut imap = Imap::new(
-        ctx,
-        transport_id,
-        configured_param.clone(),
-        r,
-    ).await?;
+    let mut imap = Imap::new(ctx, transport_id, configured_param.clone(), r).await?;
     let configuring = true;
     let mut imap_session = match imap.connect(ctx, configuring).await {
         Ok(session) => session,

src/imap.rs

@@ -260,7 +260,7 @@ impl Imap {
         let addr = &param.addr;
         let strict_tls = param.strict_tls(proxy_config.is_some());
         let oauth2 = param.oauth2;
-        Ok( Imap {
+        Ok(Imap {
             transport_id,
             idle_interrupt_receiver,
             addr: addr.to_string(),

src/scheduler.rs

@@ -1,5 +1,5 @@
 use std::cmp;
-use std::iter::{self, once};
+use std::iter;
 use std::num::NonZeroUsize;
 use std::sync::atomic::Ordering;
 
@@ -214,21 +214,25 @@ impl SchedulerState {
     /// Indicate that the network likely has come back.
     pub(crate) async fn maybe_network(&self) {
         let inner = self.inner.read().await;
-        let (inbox, oboxes) = match *inner {
+        let (inboxes, oboxes) = match *inner {
             InnerSchedulerState::Started(ref scheduler) => {
                 scheduler.maybe_network();
-                let inbox = scheduler.inbox.conn_state.state.connectivity.clone();
+                let inboxes = scheduler
+                    .inboxes
+                    .iter()
+                    .map(|b| b.conn_state.state.connectivity.clone())
+                    .collect::<Vec<_>>();
                 let oboxes = scheduler
                     .oboxes
                     .iter()
                     .map(|b| b.conn_state.state.connectivity.clone())
                     .collect::<Vec<_>>();
-                (inbox, oboxes)
+                (inboxes, oboxes)
             }
             _ => return,
         };
         drop(inner);
-        connectivity::idle_interrupted(inbox, oboxes);
+        connectivity::idle_interrupted(inboxes, oboxes);
     }
 
     /// Indicate that the network likely is lost.
@@ -333,7 +337,8 @@ struct SchedBox {
 /// Job and connection scheduler.
 #[derive(Debug)]
 pub(crate) struct Scheduler {
-    inbox: SchedBox,
+    /// Inboxes, one per transport.
+    inboxes: Vec<SchedBox>,
     /// Optional boxes -- mvbox.
     oboxes: Vec<SchedBox>,
     smtp: SmtpConnectionState,
@@ -860,38 +865,40 @@ impl Scheduler {
         let (ephemeral_interrupt_send, ephemeral_interrupt_recv) = channel::bounded(1);
         let (location_interrupt_send, location_interrupt_recv) = channel::bounded(1);
 
+        let mut inboxes = Vec::new();
         let mut oboxes = Vec::new();
         let mut start_recvs = Vec::new();
 
-        let (transport_id, configured_login_param) = ConfiguredLoginParam::load(ctx)
-            .await?
-            .context("Not configured")?;
-        let (conn_state, inbox_handlers) =
-            ImapConnectionState::new(ctx, transport_id, configured_login_param.clone()).await?;
-        let (inbox_start_send, inbox_start_recv) = oneshot::channel();
-        let handle = {
-            let ctx = ctx.clone();
-            task::spawn(inbox_loop(ctx, inbox_start_send, inbox_handlers))
-        };
-        let inbox = SchedBox {
-            meaning: FolderMeaning::Inbox,
-            conn_state,
-            handle,
-        };
-        start_recvs.push(inbox_start_recv);
-
-        if ctx.should_watch_mvbox().await? {
-            let (conn_state, handlers) = ImapConnectionState::new(ctx, transport_id, configured_login_param).await?;
-            let (start_send, start_recv) = oneshot::channel();
-            let ctx = ctx.clone();
-            let meaning = FolderMeaning::Mvbox;
-            let handle = task::spawn(simple_imap_loop(ctx, start_send, handlers, meaning));
-            oboxes.push(SchedBox {
-                meaning,
+        for (transport_id, configured_login_param) in ConfiguredLoginParam::load_all(ctx).await? {
+            let (conn_state, inbox_handlers) =
+                ImapConnectionState::new(ctx, transport_id, configured_login_param.clone()).await?;
+            let (inbox_start_send, inbox_start_recv) = oneshot::channel();
+            let handle = {
+                let ctx = ctx.clone();
+                task::spawn(inbox_loop(ctx, inbox_start_send, inbox_handlers))
+            };
+            let inbox = SchedBox {
+                meaning: FolderMeaning::Inbox,
                 conn_state,
                 handle,
-            });
-            start_recvs.push(start_recv);
+            };
+            inboxes.push(inbox);
+            start_recvs.push(inbox_start_recv);
+
+            if ctx.should_watch_mvbox().await? {
+                let (conn_state, handlers) =
+                    ImapConnectionState::new(ctx, transport_id, configured_login_param).await?;
+                let (start_send, start_recv) = oneshot::channel();
+                let ctx = ctx.clone();
+                let meaning = FolderMeaning::Mvbox;
+                let handle = task::spawn(simple_imap_loop(ctx, start_send, handlers, meaning));
+                oboxes.push(SchedBox {
+                    meaning,
+                    conn_state,
+                    handle,
+                });
+                start_recvs.push(start_recv);
+            }
         }
 
         let smtp_handle = {
@@ -917,7 +924,7 @@ impl Scheduler {
         let recently_seen_loop = RecentlySeenLoop::new(ctx.clone());
 
         let res = Self {
-            inbox,
+            inboxes,
             oboxes,
             smtp,
             smtp_handle,
@@ -937,8 +944,8 @@ impl Scheduler {
         Ok(res)
     }
 
-    fn boxes(&self) -> iter::Chain<iter::Once<&SchedBox>, std::slice::Iter<'_, SchedBox>> {
-        once(&self.inbox).chain(self.oboxes.iter())
+    fn boxes(&self) -> iter::Chain<std::slice::Iter<'_, SchedBox>, std::slice::Iter<'_, SchedBox>> {
+        self.inboxes.iter().chain(self.oboxes.iter())
     }
 
     fn maybe_network(&self) {
@@ -956,7 +963,9 @@ impl Scheduler {
     }
 
     fn interrupt_inbox(&self) {
-        self.inbox.conn_state.interrupt();
+        for b in &self.inboxes {
+            b.conn_state.interrupt();
+        }
     }
 
     fn interrupt_oboxes(&self) {
@@ -996,7 +1005,7 @@ impl Scheduler {
         let timeout_duration = std::time::Duration::from_secs(30);
 
         let tracker = TaskTracker::new();
-        for b in once(self.inbox).chain(self.oboxes) {
+        for b in self.inboxes.into_iter().chain(self.oboxes.into_iter()) {
             let context = context.clone();
             tracker.spawn(async move {
                 tokio::time::timeout(timeout_duration, b.handle)

src/scheduler/connectivity.rs

@@ -202,19 +202,20 @@ impl ConnectivityStore {
 /// Set all folder states to InterruptingIdle in case they were `Idle` before.
 /// Called during `dc_maybe_network()` to make sure that `all_work_done()`
 /// returns false immediately after `dc_maybe_network()`.
-pub(crate) fn idle_interrupted(inbox: ConnectivityStore, oboxes: Vec<ConnectivityStore>) {
-    let mut connectivity_lock = inbox.0.lock();
-    // For the inbox, we also have to set the connectivity to InterruptingIdle if it was
-    // NotConfigured before: If all folders are NotConfigured, dc_get_connectivity()
-    // returns Connected. But after dc_maybe_network(), dc_get_connectivity() must not
-    // return Connected until DC is completely done with fetching folders; this also
-    // includes scan_folders() which happens on the inbox thread.
-    if *connectivity_lock == DetailedConnectivity::Idle
-        || *connectivity_lock == DetailedConnectivity::NotConfigured
-    {
-        *connectivity_lock = DetailedConnectivity::InterruptingIdle;
+pub(crate) fn idle_interrupted(inboxes: Vec<ConnectivityStore>, oboxes: Vec<ConnectivityStore>) {
+    if let Some(inbox) = inboxes.first() {
+        let mut connectivity_lock = inbox.0.lock();
+        // For the inbox, we also have to set the connectivity to InterruptingIdle if it was
+        // NotConfigured before: If all folders are NotConfigured, dc_get_connectivity()
+        // returns Connected. But after dc_maybe_network(), dc_get_connectivity() must not
+        // return Connected until DC is completely done with fetching folders; this also
+        // includes scan_folders() which happens on the inbox thread.
+        if *connectivity_lock == DetailedConnectivity::Idle
+            || *connectivity_lock == DetailedConnectivity::NotConfigured
+        {
+            *connectivity_lock = DetailedConnectivity::InterruptingIdle;
+        }
     }
-    drop(connectivity_lock);
 
     for state in oboxes {
         let mut connectivity_lock = state.0.lock();