Merge pull request #824 from bgurney-rh/rust-1.67

mulkieran · web-flow · commit 2f07c079d1e7 · 2023-01-27T17:23:33.000-05:00
Resolve clippy 1.67 errors
diff --git a/build.rs b/build.rs
@@ -11,8 +11,7 @@ static DM_VERSIONS: &[&str] = &["4.1.0", "4.2.0", "4.6.0", "4.37.0", "4.41.0"];
 
 fn main() {
     let version = Version::parse(&format!(
-        "{}.{}.{}",
-        DM_VERSION_MAJOR, DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL
+        "{DM_VERSION_MAJOR}.{DM_VERSION_MINOR}.{DM_VERSION_PATCHLEVEL}"
     ))
     .expect("simple version string is not parseable");
 
diff --git a/src/cachedev.rs b/src/cachedev.rs
@@ -154,7 +154,7 @@ impl TargetParams for CacheTargetParams {
                 self.policy_args.len(),
                 self.policy_args
                     .iter()
-                    .map(|(k, v)| format!("{} {}", k, v))
+                    .map(|(k, v)| format!("{k} {v}"))
                     .collect::<Vec<String>>()
                     .join(" ")
             )
@@ -556,7 +556,7 @@ impl CacheDev {
         cache_block_size: Sectors,
     ) -> DmResult<CacheDev> {
         if device_exists(dm, name)? {
-            let err_msg = format!("cachedev {} already exists", name);
+            let err_msg = format!("cachedev {name} already exists");
             return Err(DmError::Dm(ErrorEnum::Invalid, err_msg));
         }
 
@@ -713,7 +713,7 @@ impl CacheDev {
     fn parse_pairs(start_index: usize, vals: &[&str]) -> DmResult<(usize, Vec<(String, String)>)> {
         let num_pairs: usize = parse_value(vals[start_index], "number of pairs")?;
         if num_pairs % 2 != 0 {
-            let err_msg = format!("Number of args \"{}\" is not even", num_pairs);
+            let err_msg = format!("Number of args \"{num_pairs}\" is not even");
             return Err(DmError::Dm(ErrorEnum::Invalid, err_msg));
         }
         let next_start_index = start_index + num_pairs + 1;
@@ -857,7 +857,7 @@ mod tests {
 
                 assert!(!status.needs_check);
             }
-            status => panic!("unexpected thinpool status: {:?}", status),
+            status => panic!("unexpected thinpool status: {status:?}"),
         }
 
         let table = CacheDev::read_kernel_table(&dm, &DevId::Name(cache.name()))
diff --git a/src/core/device.rs b/src/core/device.rs
@@ -36,7 +36,7 @@ impl FromStr for Device {
     fn from_str(s: &str) -> Result<Device, DmError> {
         let vals = s.split(':').collect::<Vec<_>>();
         if vals.len() != 2 {
-            let err_msg = format!("value \"{}\" split into wrong number of fields", s);
+            let err_msg = format!("value \"{s}\" split into wrong number of fields");
             return Err(DmError::Core(errors::Error::InvalidArgument(err_msg)));
         }
         let major = vals[0].parse::<u32>().map_err(|_| {
diff --git a/src/core/errors.rs b/src/core/errors.rs
@@ -45,13 +45,12 @@ impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Error::ContextInit(err) => {
-                write!(f, "DM context not initialized due to IO error: {}", err)
+                write!(f, "DM context not initialized due to IO error: {err}")
             }
-            Error::InvalidArgument(err) => write!(f, "invalid argument: {}", err),
+            Error::InvalidArgument(err) => write!(f, "invalid argument: {err}"),
             Error::Ioctl(op, hdr_in, hdr_out, err) => write!(
                 f,
-                "low-level ioctl error due to nix error; ioctl number: {}, input header: {:?}, header result: {:?}, error: {}",
-                op, hdr_in, hdr_out, err
+                "low-level ioctl error due to nix error; ioctl number: {op}, input header: {hdr_in:?}, header result: {hdr_out:?}, error: {err}"
             ),
             Error::IoctlResultTooLarge => write!(
                 f,
@@ -65,7 +64,7 @@ impl std::fmt::Display for Error {
                 err
             ),
             Error::GeneralIo(err) => {
-                write!(f, "failed to perform operation due to IO error: {}", err)
+                write!(f, "failed to perform operation due to IO error: {err}")
             }
         }
     }
diff --git a/src/core/types.rs b/src/core/types.rs
@@ -44,8 +44,8 @@ pub enum DevId<'a> {
 impl<'a> fmt::Display for DevId<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            DevId::Name(name) => write!(f, "{}", name),
-            DevId::Uuid(uuid) => write!(f, "{}", uuid),
+            DevId::Name(name) => write!(f, "{name}"),
+            DevId::Uuid(uuid) => write!(f, "{uuid}"),
         }
     }
 }
diff --git a/src/lineardev.rs b/src/lineardev.rs
@@ -104,7 +104,7 @@ impl FromStr for Direction {
         } else if s == "w" {
             Ok(Direction::Writes)
         } else {
-            let err_msg = format!("Expected r or w, found {}", s);
+            let err_msg = format!("Expected r or w, found {s}");
             Err(DmError::Dm(ErrorEnum::Invalid, err_msg))
         }
     }
@@ -145,11 +145,9 @@ impl fmt::Display for FeatureArg {
         match self {
             FeatureArg::DropWrites => write!(f, "drop_writes"),
             FeatureArg::ErrorWrites => write!(f, "error_writes"),
-            FeatureArg::CorruptBioByte(offset, direction, value, flags) => write!(
-                f,
-                "corrupt_bio_byte {} {} {} {}",
-                offset, direction, value, flags
-            ),
+            FeatureArg::CorruptBioByte(offset, direction, value, flags) => {
+                write!(f, "corrupt_bio_byte {offset} {direction} {value} {flags}")
+            }
         }
     }
 }
@@ -260,7 +258,7 @@ impl FromStr for FlakeyTargetParams {
                         result.push(FeatureArg::CorruptBioByte(offset, direction, value, flags));
                     }
                     x => {
-                        let err_msg = format!("{} is an unrecognized feature parameter", x);
+                        let err_msg = format!("{x} is an unrecognized feature parameter");
                         return Err(DmError::Dm(ErrorEnum::Invalid, err_msg));
                     }
                 }
@@ -364,7 +362,7 @@ impl FromStr for LinearDevTargetParams {
         let target_type = Some(s.split_once(' ').map_or(s, |x| x.0)).ok_or_else(|| {
             DmError::Dm(
                 ErrorEnum::Invalid,
-                format!("target line string \"{}\" did not contain any values", s),
+                format!("target line string \"{s}\" did not contain any values"),
             )
         })?;
         if target_type == FLAKEY_TARGET_NAME {
@@ -378,7 +376,7 @@ impl FromStr for LinearDevTargetParams {
         } else {
             Err(DmError::Dm(
                 ErrorEnum::Invalid,
-                format!("unexpected target type \"{}\"", target_type),
+                format!("unexpected target type \"{target_type}\""),
             ))
         }
     }
diff --git a/src/result.rs b/src/result.rs
@@ -45,8 +45,8 @@ impl From<errors::Error> for DmError {
 impl fmt::Display for DmError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            DmError::Core(ref err) => write!(f, "DM Core error: {}", err),
-            DmError::Dm(ref err, ref msg) => write!(f, "DM error: {}: {}", err, msg),
+            DmError::Core(ref err) => write!(f, "DM Core error: {err}"),
+            DmError::Dm(ref err, ref msg) => write!(f, "DM error: {err}: {msg}"),
         }
     }
 }
diff --git a/src/shared.rs b/src/shared.rs
@@ -165,8 +165,7 @@ pub fn device_match<T: TargetTable, D: DmDevice<T>>(
     let device_table = dev.table();
     if !D::equivalent_tables(&kernel_table, device_table)? {
         let err_msg = format!(
-            "Specified new table \"{:?}\" does not match kernel table \"{:?}\"",
-            device_table, kernel_table
+            "Specified new table \"{device_table:?}\" does not match kernel table \"{kernel_table:?}\""
         );
 
         return Err(DmError::Dm(ErrorEnum::Invalid, err_msg));
@@ -187,7 +186,7 @@ pub fn device_match<T: TargetTable, D: DmDevice<T>>(
 /// Check if a device of the given name exists.
 pub fn device_exists(dm: &DM, name: &DmName) -> DmResult<bool> {
     dm.list_devices()
-        .map(|l| l.iter().any(|&(ref n, _, _)| &**n == name))
+        .map(|l| l.iter().any(|(n, _, _)| &**n == name))
 }
 
 /// Parse a device from either of a path or a maj:min pair
@@ -197,7 +196,7 @@ pub fn parse_device(val: &str, desc: &str) -> DmResult<Device> {
             .ok_or_else(|| {
                 DmError::Dm(
                     ErrorEnum::Invalid,
-                    format!("Failed to parse \"{}\" from input \"{}\"", desc, val),
+                    format!("Failed to parse \"{desc}\" from input \"{val}\""),
                 )
             })?
             .into()
@@ -215,10 +214,7 @@ where
     val.parse::<T>().map_err(|_| {
         DmError::Dm(
             ErrorEnum::Invalid,
-            format!(
-                "Failed to parse value for \"{}\" from input \"{}\"",
-                desc, val
-            ),
+            format!("Failed to parse value for \"{desc}\" from input \"{val}\""),
         )
     })
 }
@@ -232,8 +228,7 @@ pub fn get_status_line_fields(status_line: &str, number_required: usize) -> DmRe
         return Err(DmError::Dm(
             ErrorEnum::Invalid,
             format!(
-                "Insufficient number of fields for status; requires at least {}, found only {} in status line \"{}\"",
-                number_required, length, status_line
+                "Insufficient number of fields for status; requires at least {number_required}, found only {length} in status line \"{status_line}\""
             ),
         ));
     }
@@ -250,7 +245,7 @@ pub fn get_status(status_lines: &[(u64, u64, String, String)]) -> DmResult<Strin
             format!(
                 "Incorrect number of lines for status; expected 1, found {} in status result \"{}\"",
                 length,
-                status_lines.iter().map(|(s, l, t, v)| format!("{} {} {} {}", s, l, t, v)).collect::<Vec<String>>().join(", ")
+                status_lines.iter().map(|(s, l, t, v)| format!("{s} {l} {t} {v}")).collect::<Vec<String>>().join(", ")
             ),
         ));
     }
@@ -268,8 +263,7 @@ pub fn make_unexpected_value_error(value_index: usize, value: &str, item_name: &
     DmError::Dm(
         ErrorEnum::Invalid,
         format!(
-            "Kernel returned unexpected {}th value \"{}\" for item representing {} in status result",
-            value_index, value, item_name
+            "Kernel returned unexpected {value_index}th value \"{value}\" for item representing {item_name} in status result"
         ),
     )
 }
diff --git a/src/testing/test_lib.rs b/src/testing/test_lib.rs
@@ -84,18 +84,15 @@ fn execute_cmd(cmd: &mut Command) -> DmResult<()> {
     match cmd.output() {
         Err(err) => Err(DmError::Dm(
             ErrorEnum::Error,
-            format!("cmd: {:?}, error '{}'", cmd, err),
+            format!("cmd: {cmd:?}, error '{err}'"),
         )),
         Ok(result) => {
             if result.status.success() {
                 Ok(())
             } else {
                 let std_out_txt = String::from_utf8_lossy(&result.stdout);
                 let std_err_txt = String::from_utf8_lossy(&result.stderr);
-                let err_msg = format!(
-                    "cmd: {:?} stdout: {} stderr: {}",
-                    cmd, std_out_txt, std_err_txt
-                );
+                let err_msg = format!("cmd: {cmd:?} stdout: {std_out_txt} stderr: {std_err_txt}");
                 Err(DmError::Dm(ErrorEnum::Error, err_msg))
             }
         }
@@ -111,7 +108,7 @@ pub fn xfs_create_fs(devnode: &Path, uuid: Option<Uuid>) -> DmResult<()> {
 
     if let Some(uuid) = uuid {
         command.arg("-m");
-        command.arg(format!("uuid={}", uuid));
+        command.arg(format!("uuid={uuid}"));
     }
     execute_cmd(&mut command)
 }
@@ -121,7 +118,7 @@ pub fn xfs_set_uuid(devnode: &Path, uuid: &Uuid) -> DmResult<()> {
     execute_cmd(
         Command::new("xfs_admin")
             .arg("-U")
-            .arg(format!("{}", uuid))
+            .arg(format!("{uuid}"))
             .arg(devnode),
     )
 }
@@ -233,7 +230,7 @@ fn dm_test_devices_remove() -> Result<()> {
 
         do_while_progress().and_then(|remain| {
             if !remain.is_empty() {
-                let err_msg = format!("Some test-generated DM devices remaining: {:?}", remain);
+                let err_msg = format!("Some test-generated DM devices remaining: {remain:?}");
                 Err(err_msg.into())
             } else {
                 Ok(())
diff --git a/src/thindev.rs b/src/thindev.rs
@@ -52,10 +52,7 @@ impl FromStr for ThinTargetParams {
         let vals = s.split(' ').collect::<Vec<_>>();
         let len = vals.len();
         if !(3..=4).contains(&len) {
-            let err_msg = format!(
-                "expected 3 or 4 values in params string \"{}\", found {}",
-                s, len
-            );
+            let err_msg = format!("expected 3 or 4 values in params string \"{s}\", found {len}");
             return Err(DmError::Dm(ErrorEnum::Invalid, err_msg));
         }
 
@@ -257,7 +254,7 @@ impl ThinDev {
         thin_pool: &ThinPoolDev,
         thin_id: ThinDevId,
     ) -> DmResult<ThinDev> {
-        message(dm, thin_pool, &format!("create_thin {}", thin_id))?;
+        message(dm, thin_pool, &format!("create_thin {thin_id}"))?;
 
         if device_exists(dm, name)? {
             let err_msg = "Uncreated device should not be known to kernel";
@@ -405,7 +402,7 @@ impl ThinDev {
     pub fn destroy(&mut self, dm: &DM, thin_pool: &ThinPoolDev) -> DmResult<()> {
         let thin_id = self.table.table.params.thin_id;
         self.teardown(dm)?;
-        message(dm, thin_pool, &format!("delete {}", thin_id))?;
+        message(dm, thin_pool, &format!("delete {thin_id}"))?;
         Ok(())
     }
 }
@@ -557,7 +554,7 @@ mod tests {
             udev_settle().unwrap();
 
             // Make sure the uuid symlink was created
-            let symlink = PathBuf::from(format!("/dev/disk/by-uuid/{}", path_uuid));
+            let symlink = PathBuf::from(format!("/dev/disk/by-uuid/{path_uuid}"));
             assert!(symlink.exists());
 
             assert_eq!(*devnode, canonicalize(symlink).unwrap());
@@ -721,7 +718,7 @@ mod tests {
         .unwrap();
 
         for i in 0..100 {
-            let file_path = tmp_dir.path().join(format!("devicemapper_test{}.txt", i));
+            let file_path = tmp_dir.path().join(format!("devicemapper_test{i}.txt"));
             writeln!(
                 &OpenOptions::new()
                     .create(true)
diff --git a/src/thindevid.rs b/src/thindevid.rs
@@ -28,7 +28,7 @@ impl ThinDevId {
         } else {
             Err(DmError::Dm(
                 ErrorEnum::Invalid,
-                format!("argument {} unrepresentable in 24 bits", value),
+                format!("argument {value} unrepresentable in 24 bits"),
             ))
         }
     }
diff --git a/src/thinpooldev.rs b/src/thinpooldev.rs
@@ -441,7 +441,7 @@ impl ThinPoolDev {
         feature_args: Vec<String>,
     ) -> DmResult<ThinPoolDev> {
         if device_exists(dm, name)? {
-            let err_msg = format!("thinpooldev {} already exists", name);
+            let err_msg = format!("thinpooldev {name} already exists");
             return Err(DmError::Dm(ErrorEnum::Invalid, err_msg));
         }
 
@@ -813,7 +813,7 @@ mod tests {
                     DataBlocks(tp.data_dev().size() / tp.data_block_size())
                 );
             }
-            status => panic!("unexpected thinpool status: {:?}", status),
+            status => panic!("unexpected thinpool status: {status:?}"),
         }
 
         let table = ThinPoolDev::read_kernel_table(&dm, &DevId::Name(tp.name()))

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ impl FromStr for Device {`
`36`	`36`	`fn from_str(s: &str) -> Result<Device, DmError> {`
`37`	`37`	`let vals = s.split(':').collect::<Vec<_>>();`
`38`	`38`	`if vals.len() != 2 {`
`39`		`- let err_msg = format!("value \"{}\" split into wrong number of fields", s);`
	`39`	`+ let err_msg = format!("value \"{s}\" split into wrong number of fields");`
`40`	`40`	`return Err(DmError::Core(errors::Error::InvalidArgument(err_msg)));`
`41`	`41`	`}`
`42`	`42`	`let major = vals[0].parse::<u32>().map_err(\|_\| {`
Original file line number	Diff line number	Diff line change
`@@ -44,8 +44,8 @@ pub enum DevId<'a> {`
`44`	`44`	`impl<'a> fmt::Display for DevId<'a> {`
`45`	`45`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`46`	`46`	`match *self {`
`47`		`- DevId::Name(name) => write!(f, "{}", name),`
`48`		`- DevId::Uuid(uuid) => write!(f, "{}", uuid),`
	`47`	`+ DevId::Name(name) => write!(f, "{name}"),`
	`48`	`+ DevId::Uuid(uuid) => write!(f, "{uuid}"),`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ impl FromStr for Direction {`
`104`	`104`	`} else if s == "w" {`
`105`	`105`	`Ok(Direction::Writes)`
`106`	`106`	`} else {`
`107`		`- let err_msg = format!("Expected r or w, found {}", s);`
	`107`	`+ let err_msg = format!("Expected r or w, found {s}");`
`108`	`108`	`Err(DmError::Dm(ErrorEnum::Invalid, err_msg))`
`109`	`109`	`}`
`110`	`110`	`}`
`@@ -145,11 +145,9 @@ impl fmt::Display for FeatureArg {`
`145`	`145`	`match self {`
`146`	`146`	`FeatureArg::DropWrites => write!(f, "drop_writes"),`
`147`	`147`	`FeatureArg::ErrorWrites => write!(f, "error_writes"),`
`148`		`- FeatureArg::CorruptBioByte(offset, direction, value, flags) => write!(`
`149`		`- f,`
`150`		`- "corrupt_bio_byte {} {} {} {}",`
`151`		`- offset, direction, value, flags`
`152`		`- ),`
	`148`	`+ FeatureArg::CorruptBioByte(offset, direction, value, flags) => {`
	`149`	`+ write!(f, "corrupt_bio_byte {offset} {direction} {value} {flags}")`
	`150`	`+ }`
`153`	`151`	`}`
`154`	`152`	`}`
`155`	`153`	`}`
`@@ -260,7 +258,7 @@ impl FromStr for FlakeyTargetParams {`
`260`	`258`	`result.push(FeatureArg::CorruptBioByte(offset, direction, value, flags));`
`261`	`259`	`}`
`262`	`260`	`x => {`
`263`		`- let err_msg = format!("{} is an unrecognized feature parameter", x);`
	`261`	`+ let err_msg = format!("{x} is an unrecognized feature parameter");`
`264`	`262`	`return Err(DmError::Dm(ErrorEnum::Invalid, err_msg));`
`265`	`263`	`}`
`266`	`264`	`}`
`@@ -364,7 +362,7 @@ impl FromStr for LinearDevTargetParams {`
`364`	`362`	`let target_type = Some(s.split_once(' ').map_or(s, \|x\| x.0)).ok_or_else(\|\| {`
`365`	`363`	`DmError::Dm(`
`366`	`364`	`ErrorEnum::Invalid,`
`367`		`- format!("target line string \"{}\" did not contain any values", s),`
	`365`	`+ format!("target line string \"{s}\" did not contain any values"),`
`368`	`366`	`)`
`369`	`367`	`})?;`
`370`	`368`	`if target_type == FLAKEY_TARGET_NAME {`
`@@ -378,7 +376,7 @@ impl FromStr for LinearDevTargetParams {`
`378`	`376`	`} else {`
`379`	`377`	`Err(DmError::Dm(`
`380`	`378`	`ErrorEnum::Invalid,`
`381`		`- format!("unexpected target type \"{}\"", target_type),`
	`379`	`+ format!("unexpected target type \"{target_type}\""),`
`382`	`380`	`))`
`383`	`381`	`}`
`384`	`382`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,8 +45,8 @@ impl From<errors::Error> for DmError {`
`45`	`45`	`impl fmt::Display for DmError {`
`46`	`46`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`47`	`47`	`match *self {`
`48`		`- DmError::Core(ref err) => write!(f, "DM Core error: {}", err),`
`49`		`- DmError::Dm(ref err, ref msg) => write!(f, "DM error: {}: {}", err, msg),`
	`48`	`+ DmError::Core(ref err) => write!(f, "DM Core error: {err}"),`
	`49`	`+ DmError::Dm(ref err, ref msg) => write!(f, "DM error: {err}: {msg}"),`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`	`}`