versions: update rust version

Fixes #4764

versions: update rust version to fix ccv0 attestation-agent build error
static-checks: kata tools, libs, and agent fixes

Signed-Off-By: Ryan Savino <ryan.savino@amd.com>

src/agent/rustjail/src/mount.rs

@@ -780,7 +780,7 @@ fn mount_from(
             Path::new(&dest).parent().unwrap()
         };
 
-        let _ = fs::create_dir_all(&dir).map_err(|e| {
+        fs::create_dir_all(&dir).map_err(|e| {
             log_child!(
                 cfd_log,
                 "create dir {}: {}",

src/agent/src/main.rs

@@ -209,7 +209,7 @@ async fn real_main() -> std::result::Result<(), Box<dyn std::error::Error>> {
 
     if config.log_level == slog::Level::Trace {
         // Redirect ttrpc log calls to slog iff full debug requested
-        ttrpc_log_guard = Ok(slog_stdlog::init().map_err(|e| e)?);
+        ttrpc_log_guard = Ok(slog_stdlog::init()?);
     }
 
     if config.tracing {

src/libs/logging/src/lib.rs

@@ -529,12 +529,12 @@ mod tests {
 
             // Create a writer for the logger drain to use
             let writer =
-                NamedTempFile::new().expect(&format!("{:}: failed to create tempfile", msg));
+                NamedTempFile::new().unwrap_or_else(|_| panic!("{:}: failed to create tempfile", msg));
 
             // Used to check file contents before the temp file is unlinked
             let mut writer_ref = writer
                 .reopen()
-                .expect(&format!("{:?}: failed to clone tempfile", msg));
+                .unwrap_or_else(|_| panic!("{:?}: failed to clone tempfile", msg));
 
             let (logger, logger_guard) = create_logger(name, source, d.slog_level, writer);
 
@@ -548,52 +548,52 @@ mod tests {
             let mut contents = String::new();
             writer_ref
                 .read_to_string(&mut contents)
-                .expect(&format!("{:?}: failed to read tempfile contents", msg));
+                .unwrap_or_else(|_| panic!("{:?}: failed to read tempfile contents", msg));
 
             // Convert file to JSON
             let fields: Value = serde_json::from_str(&contents)
-                .expect(&format!("{:?}: failed to convert logfile to json", msg));
+                .unwrap_or_else(|_| panic!("{:?}: failed to convert logfile to json", msg));
 
             // Check the expected JSON fields
 
             let field_ts = fields
                 .get("ts")
-                .expect(&format!("{:?}: failed to find timestamp field", msg));
+                .unwrap_or_else(|| panic!("{:?}: failed to find timestamp field", msg));
             assert_ne!(field_ts, "", "{}", msg);
 
             let field_version = fields
                 .get("version")
-                .expect(&format!("{:?}: failed to find version field", msg));
+                .unwrap_or_else(|| panic!("{:?}: failed to find version field", msg));
             assert_eq!(field_version, env!("CARGO_PKG_VERSION"), "{}", msg);
 
             let field_pid = fields
                 .get("pid")
-                .expect(&format!("{:?}: failed to find pid field", msg));
+                .unwrap_or_else(|| panic!("{:?}: failed to find pid field", msg));
             assert_ne!(field_pid, "", "{}", msg);
 
             let field_level = fields
                 .get("level")
-                .expect(&format!("{:?}: failed to find level field", msg));
+                .unwrap_or_else(|| panic!("{:?}: failed to find level field", msg));
             assert_eq!(field_level, d.slog_level_tag, "{}", msg);
 
             let field_msg = fields
                 .get("msg")
-                .expect(&format!("{:?}: failed to find msg field", msg));
+                .unwrap_or_else(|| panic!("{:?}: failed to find msg field", msg));
             assert_eq!(field_msg, &json!(d.msg), "{}", msg);
 
             let field_name = fields
                 .get("name")
-                .expect(&format!("{:?}: failed to find name field", msg));
+                .unwrap_or_else(|| panic!("{:?}: failed to find name field", msg));
             assert_eq!(field_name, name, "{}", msg);
 
             let field_source = fields
                 .get("source")
-                .expect(&format!("{:?}: failed to find source field", msg));
+                .unwrap_or_else(|| panic!("{:?}: failed to find source field", msg));
             assert_eq!(field_source, source, "{}", msg);
 
             let field_subsystem = fields
                 .get("subsystem")
-                .expect(&format!("{:?}: failed to find subsystem field", msg));
+                .unwrap_or_else(|| panic!("{:?}: failed to find subsystem field", msg));
 
             // No explicit subsystem, so should be the default
             assert_eq!(field_subsystem, &json!(DEFAULT_SUBSYSTEM), "{}", msg);

src/tools/agent-ctl/src/main.rs

@@ -163,7 +163,7 @@ fn connect(name: &str, global_args: clap::ArgMatches) -> Result<()> {
     let (logger, _guard) = logging::create_logger(name, crate_name!(), log_level, writer);
 
     let timeout_nano: i64 = match args.value_of("timeout") {
-        Some(t) => utils::human_time_to_ns(t).map_err(|e| e)?,
+        Some(t) => utils::human_time_to_ns(t)?,
         None => 0,
     };
 

src/tools/agent-ctl/src/utils.rs

@@ -688,7 +688,7 @@ fn oci_to_ttrpc(bundle_dir: &str, cid: &str, oci: &ociSpec) -> Result<ttrpcSpec>
 
     let root = match &oci.root {
         Some(r) => {
-            let ttrpc_root = root_oci_to_ttrpc(bundle_dir, r).map_err(|e| e)?;
+            let ttrpc_root = root_oci_to_ttrpc(bundle_dir, r)?;
 
             protobuf::SingularPtrField::some(ttrpc_root)
         }

src/tools/runk/src/commands/delete.rs

@@ -72,13 +72,10 @@ pub async fn run(opts: Delete, root: &Path, logger: &Logger) -> Result<()> {
         }
         _ => {
             if opts.force {
-                match kill(Pid::from_raw(status.pid), Some(Signal::SIGKILL)) {
+                if let Err(errno) = kill(Pid::from_raw(status.pid), Some(Signal::SIGKILL)) {
-                    Err(errno) => {
+                    if errno != Errno::ESRCH {
-                        if errno != Errno::ESRCH {
+                        return Err(anyhow!("{}", errno));
-                            return Err(anyhow!("{}", errno));
-                        }
                     }
-                    Ok(()) => {}
                 }
                 destroy_container(&status)?;
             } else {

src/tools/runk/src/commands/list.rs

@@ -9,6 +9,7 @@ use libcontainer::status::{get_current_container_state, Status};
 use liboci_cli::List;
 use oci::ContainerState;
 use slog::{info, Logger};
+use std::fmt::Write as _;
 use std::{fs, os::unix::prelude::MetadataExt, path::Path};
 use std::{io, io::Write};
 use tabwriter::TabWriter;
@@ -48,15 +49,16 @@ pub fn run(_: List, root: &Path, logger: &Logger) -> Result<()> {
             Some(user) => String::from(user.name().to_string_lossy()),
             None => format!("#{}", metadata.uid()),
         };
-        content.push_str(&format!(
+        let _ = writeln!(
-            "{}\t{}\t{}\t{}\t{}\t{}\n",
+            content,
+            "{}\t{}\t{}\t{}\t{}\t{}",
             container_id,
             pid,
             get_container_state_name(state),
             status.bundle.display(),
             status.created,
             owner
-        ));
+        );
     }
 
     let mut tab_writer = TabWriter::new(io::stdout());

versions.yaml

@@ -294,12 +294,12 @@ languages:
   rust:
     description: "Rust language"
     notes: "'version' is the default minimum version used by this project."
-    version: "1.58.1"
+    version: "1.62.0"
     meta:
       description: |
         'newest-version' is the latest version known to work when
         building Kata
-      newest-version: "1.58.1"
+      newest-version: "1.62.0"
 
 specs:
   description: "Details of important specifications"