clippy (client)

Author: djugei

client/src/main.rs

@@ -113,11 +113,7 @@ fn default_blacklist() -> Vec<Str> {
         "rocblas",
     ];
 
-    let mut v: Vec<_> = bad_compress
-        .into_iter()
-        .chain(too_big.into_iter())
-        .map(Str::from)
-        .collect();
+    let mut v: Vec<_> = bad_compress.into_iter().chain(too_big).map(Str::from).collect();
     v.sort();
     v
 }
@@ -298,17 +294,18 @@ async fn do_upgrade(
 
     let localset = tokio::task::LocalSet::new();
     let mut set = JoinSet::new();
-    for (url, newpkg, oldpkg, oldfile, dec_size) in upgrade_candidates {
+    for (url, delta, oldfile, dec_size) in upgrade_candidates {
+        let (oldpkg, newpkg) = delta.get_both();
         let get_delta_f = get_delta(
             global.clone(),
             newpkg.clone(),
             oldpkg.clone(),
             oldfile,
-            dec_size.clone(),
+            dec_size,
             delta_cache.clone(),
             server.clone(),
         );
-        let get_sig_f = get_signature(url.into(), global.client.clone(), delta_cache.clone(), newpkg.clone());
+        let get_sig_f = get_signature(url, global.client.clone(), delta_cache.clone(), newpkg.clone());
 
         set.spawn_local_on(
             async move {
@@ -331,7 +328,7 @@ async fn do_upgrade(
             let boring_dl = util::do_boring_download(global.clone(), url.clone(), delta_cache.clone());
             let name = url.path_segments().and_then(Iterator::last).context("malformed url")?;
             let pkg = Package::try_from(name).unwrap();
-            let get_sig_f = get_signature(url.as_str().into(), global.client.clone(), delta_cache.clone(), pkg);
+            let get_sig_f = get_signature(url, global.client.clone(), delta_cache.clone(), pkg);
             dlset.spawn_local_on(
                 async move {
                     let (f, s) = tokio::join!(boring_dl, get_sig_f);
@@ -368,7 +365,9 @@ async fn do_upgrade(
                 deltasize += d;
                 newsize += n;
                 if let Some(c) = c {
-                    comptime.as_mut().map(|sum: &mut Duration| *sum += c);
+                    if let Some(comptime) = &mut comptime {
+                        *comptime += c
+                    }
                 }
             }
         }
@@ -495,7 +494,7 @@ async fn get_delta(
     Ok((deltasize, newsize, comptime))
 }
 
-async fn get_signature(url: Str, client: Client, delta_cache: PathBuf, newpkg: Package) -> Result<(), anyhow::Error> {
+async fn get_signature(url: Url, client: Client, delta_cache: PathBuf, newpkg: Package) -> Result<(), anyhow::Error> {
     let mut sigfile = delta_cache.clone();
     sigfile.push(format!("{newpkg}.sig"));
     let mut sigfile = match tokio::fs::OpenOptions::new()
@@ -519,11 +518,11 @@ async fn get_signature(url: Str, client: Client, delta_cache: PathBuf, newpkg: P
 }
 
 trait ResultSwap<T, E> {
-    fn swap(self: Self) -> Result<E, T>;
+    fn swap(self) -> Result<E, T>;
 }
 
 impl<T, E> ResultSwap<T, E> for Result<T, E> {
-    fn swap(self: Self) -> Result<E, T> {
+    fn swap(self) -> Result<E, T> {
         match self {
             Ok(t) => Err(t),
             Err(e) => Ok(e),
@@ -548,7 +547,12 @@ fn gen_delta(orig: &Path, new: &Path, patch: &Path) -> Result<(), std::io::Error
     let newb_len = newb.len();
     let mut newb = Cursor::new(newb);
 
-    let patch = OpenOptions::new().write(true).create(true).open(patch).unwrap();
+    let patch = OpenOptions::new()
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(patch)
+        .unwrap();
     let mut patch = zstd::Encoder::new(patch, 22)?;
 
     let before = memory_stats::memory_stats().unwrap().physical_mem;
@@ -641,7 +645,7 @@ fn apply_patch(orig: &[u8], patch: &Path, new: &Path, pb: ProgressBar) -> anyhow
 
         // gotta drain stdout into file while at the same time writing into stdin
         // otherwise the internal buffer of stdin/out is full and it deadlocks
-        let mut new_f = OpenOptions::new().write(true).create(true).open(new)?;
+        let mut new_f = OpenOptions::new().write(true).create(true).truncate(false).open(new)?;
         let handle = std::thread::spawn(move || -> std::io::Result<()> {
             std::io::copy(&mut stdout, &mut new_f)?;
             Ok(())

client/src/util.rs

@@ -2,7 +2,7 @@ use std::{collections::HashMap, io::Read, path::PathBuf};
 
 use anyhow::{Context, bail};
 use bytesize::ByteSize;
-use common::Package;
+use common::{Delta, Package};
 use http::StatusCode;
 use indicatif::{ProgressBar, ProgressStyle};
 use itertools::Itertools;
@@ -63,11 +63,13 @@ pub(crate) async fn do_boring_download(
     Ok(size)
 }
 
+type DeltaUpgradeCandidate = (Url, Delta, Mmap, u64);
+
 pub(crate) fn find_deltaupgrade_candidates(
     _global: &crate::GlobalState,
     blacklist: &[Str],
     _fuz: bool,
-) -> Result<(Vec<(String, Package, Package, Mmap, u64)>, Vec<Url>), anyhow::Error> {
+) -> Result<(Vec<DeltaUpgradeCandidate>, Vec<Url>), anyhow::Error> {
     let upgrades = libalpm_rs::upgrade_urls(&["core", "extra", "multilib"]);
 
     let mut direct_downloads = Vec::new();
@@ -81,7 +83,7 @@ pub(crate) fn find_deltaupgrade_candidates(
         }
         let i = old.i.borrow();
         let old_name = old.name.r(&i);
-        if (&blacklist).into_iter().any(|e| **e == *old_name) {
+        if blacklist.iter().any(|e| **e == *old_name) {
             info!("{old_name} is blacklisted, skipping");
             continue;
         }
@@ -116,20 +118,20 @@ pub(crate) fn find_deltaupgrade_candidates(
                 let new_filename = new.filename.unwrap().r(&i);
                 let newpkg = Package::try_from(new_filename)?;
 
-                deltas.push((url, newpkg, oldpkg, oldfile, (dec_size as u64)));
+                deltas.push((Url::parse(&url)?, Delta::try_from((oldpkg, newpkg))?, oldfile, dec_size));
             }
             Err(e) => {
                 if e.kind() == std::io::ErrorKind::NotFound {
                     debug!("direct download {old_name}-{old_version}");
                     //TODO: re-add fuzzy logic
                     direct_downloads.push(Url::parse(&url)?);
                 } else {
-                    return Err(e)?;
+                    Err(e)?;
                 }
             }
         }
     }
-    return Ok((deltas, direct_downloads));
+    Ok((deltas, direct_downloads))
 }
 
 pub async fn sync_db(global: crate::GlobalState, server: Url, name: Str) -> anyhow::Result<()> {
@@ -245,11 +247,11 @@ pub(crate) fn calc_stats(count: usize) -> std::io::Result<()> {
         let filename: String = filename.into_string().unwrap();
         if filename.ends_with(".delta") {
             let (_old, new) = filename.rsplit_once(":to:").unwrap();
-            let pkg = Package::try_from(&*new).unwrap();
+            let pkg = Package::try_from(new).unwrap();
             let (name, version, arch, trailer) = pkg.destructure();
             assert_eq!(&*trailer, "delta");
             let len = line.metadata()?.len();
-            deltas.insert((name.into(), version.into(), arch.into()), len);
+            deltas.insert((name, version, arch), len);
         } else if filename.ends_with(".pkg.tar.zst") {
             let (name, version, arch, _trailer) = Package::try_from(filename.as_str())
                 .expect("weird pkg file name")
@@ -278,10 +280,9 @@ pub(crate) fn calc_stats(count: usize) -> std::io::Result<()> {
     }
     let mut unmatched = 0;
     for ((name, version, arch), len) in pkgs.drain() {
-        if log::log_enabled!(log::Level::Trace) {
-            if !deltas.contains_key(&(name.clone(), version.clone(), arch.clone())) {
-                trace!("pkg: {name} {version} {arch} unmatched");
-            }
+        if log::log_enabled!(log::Level::Trace) && !deltas.contains_key(&(name.clone(), version.clone(), arch.clone()))
+        {
+            trace!("pkg: {name} {version} {arch} unmatched");
         }
         if let Some(((name, _version, _arch), dlen)) = deltas.remove_entry(&(name, version, arch)) {
             pairs