use 2018-style modules

src/daemon/mod.rs → src/daemon.rs

@@ -69,9 +69,9 @@ pub enum FgEvent {
 }
 
 pub struct LastKnown {
-    fetch: Result<(), ReleaseError>,
+    fetch:            Result<(), ReleaseError>,
     recovery_upgrade: Result<(), RecoveryError>,
-    release_upgrade: Result<(), ReleaseError>,
+    release_upgrade:  Result<(), ReleaseError>,
 }
 
 impl Default for LastKnown {
@@ -82,20 +82,20 @@ impl Default for LastKnown {
 
 pub struct ReleaseUpgradeState {
     action: release::UpgradeMethod,
-    from: Box<str>,
-    to: Box<str>,
+    from:   Box<str>,
+    to:     Box<str>,
 }
 
 pub struct Daemon {
-    event_tx: Sender<Event>,
-    fg_rx: Receiver<FgEvent>,
-    dbus_rx: Receiver<SignalEvent>,
-    connection: Arc<Connection>,
-    status: Arc<Atomic<DaemonStatus>>,
-    sub_status: Arc<Atomic<u8>>,
-    fetching_state: Arc<Atomic<(u64, u64)>>,
-    cancel: Arc<AtomicBool>,
-    last_known: LastKnown,
+    event_tx:        Sender<Event>,
+    fg_rx:           Receiver<FgEvent>,
+    dbus_rx:         Receiver<SignalEvent>,
+    connection:      Arc<Connection>,
+    status:          Arc<Atomic<DaemonStatus>>,
+    sub_status:      Arc<Atomic<u8>>,
+    fetching_state:  Arc<Atomic<(u64, u64)>>,
+    cancel:          Arc<AtomicBool>,
+    last_known:      LastKnown,
     release_upgrade: Option<ReleaseUpgradeState>,
     perform_upgrade: bool,
 }
@@ -630,8 +630,8 @@ impl Daemon {
 
         let event = Event::RecoveryUpgrade(RecoveryUpgradeMethod::FromRelease {
             version: if version.is_empty() { None } else { Some(version.into()) },
-            arch: if arch.is_empty() { None } else { Some(arch.into()) },
-            flags: RecoveryReleaseFlags::from_bits_truncate(flags),
+            arch:    if arch.is_empty() { None } else { Some(arch.into()) },
+            flags:   RecoveryReleaseFlags::from_bits_truncate(flags),
         });
 
         self.submit_event(event)

src/fetch.rs

@@ -0,0 +1,35 @@
+pub mod apt {
+    use anyhow::Context;
+    use apt_cmd::{lock::apt_lock_wait, request::Request as AptRequest, AptGet};
+    use std::collections::HashSet;
+
+    pub async fn fetch_uris(packages: Option<&[&str]>) -> anyhow::Result<HashSet<AptRequest>> {
+        apt_lock_wait().await;
+        let mut uris = AptGet::new()
+            .noninteractive()
+            .fetch_uris(&["full-upgrade"])
+            .await
+            .context("failed to exec `apt-get full-upgrade --print-uris`")?
+            .context("failed to fetch package URIs from apt-get full-upgrade")?;
+
+        if let Some(packages) = packages {
+            apt_lock_wait().await;
+            let install_uris = AptGet::new()
+                .noninteractive()
+                .fetch_uris(&{
+                    let mut args = vec!["install"];
+                    args.extend_from_slice(packages);
+                    args
+                })
+                .await
+                .context("failed to exec `apt-get install --print-uris`")?
+                .context("failed to fetch package URIs from `apt-get install`")?;
+
+            for uri in install_uris {
+                uris.insert(uri);
+            }
+        }
+
+        Ok(uris)
+    }
+}