Merge pull request #673 from vigh-m/rust-go-update

Update first-party packages

Author: vigh-m

sources/Cargo.lock

@@ -110,7 +110,7 @@ actix-web-actors = { version = "4", default-features = false }
 argh = "0.1"
 async-trait = "0.1"
 aws-config = "1"
-aws-lc-rs = "1"
+aws-lc-rs = "=1.13.0"
 aws-sdk-cloudformation = "1"
 aws-sdk-ec2 = "1"
 aws-sdk-eks = "1"
@@ -147,7 +147,7 @@ http = "0.2"
 httparse = "1"
 httptest = "0.15"
 hyper = { version = "1", default-features = false }
-hyper-http-proxy = "1"
+hyper-http-proxy = "~1.0"
 hyper-rustls = { version = "0.27", default-features = false }
 hyper-util = { version = "0.1", default-features = false }
 hyper-unix-connector = "0.2"
@@ -156,7 +156,7 @@ ipnet = "2"
 itertools = "0.13"
 lazy_static = "1"
 libc = "0.2"
-log = "0.4.21"
+log = "0.4.28"
 lz4 = "1"
 maplit = "1.0"
 nix = "0.26"
@@ -168,11 +168,10 @@ once_cell = "1"
 pathdiff = "0.2"
 pentacle = "1"
 percent-encoding = "2"
-pest = "2.5"
-pest_derive = "2.5"
+pest = "2.8"
+pest_derive = "2.8"
 pin-project-lite = "0.2"
 proc-macro2 = "1"
-quick-xml = "0.26"
 quote = "1"
 rand = { version = "0.8", default-features = false }
 regex = "1"
@@ -204,7 +203,7 @@ tower = "0.4"
 tracing = "0.1"
 unindent = "0.2"
 url = "2"
-walkdir = "2.4"
+walkdir = "2.5"
 which = "4"
 x509-parser = "0.16"
 base64 = "0.22"

sources/Cargo.toml

@@ -147,7 +147,7 @@ where
             if let Err(e) = res {
                 let msg = e.to_string();
                 if !msg.is_empty() {
-                    error!("{}", e);
+                    error!("{e}");
                 }
             }
         }
@@ -164,7 +164,7 @@ where
         // Stop if we receive a terminal signal.
         signal = &mut signal_handler.signal_rx => {
             drop(terminal);
-            debug!("Received signal: {:?}", signal);
+            debug!("Received signal: {signal:?}");
             signal_ret = Some(signal);
         }
 
@@ -405,10 +405,10 @@ impl ReadFromUser {
                         match serde_json::to_string(&ClientMessage::ContentComplete) {
                             Ok(msg) => {
                                 if let Err(e) = tx.unbounded_send(Message::Text(msg)) {
-                                    warn!("Unable to send ContentComplete to server, may hang if process doesn't exit: {}", e);
+                                    warn!("Unable to send ContentComplete to server, may hang if process doesn't exit: {e}");
                                 }
                             }
-                            Err(e) => warn!("Unable to serialize ContentComplete, may hang if process doesn't exit: {}", e),
+                            Err(e) => warn!("Unable to serialize ContentComplete, may hang if process doesn't exit: {e}"),
                         }
                         return Ok(());
                     } else {
@@ -611,7 +611,7 @@ impl HandleSignals {
         debug!("Spawning thread to manage signals");
         thread::spawn(move || {
             if let Err(e) = Self::handle_signals(signals, winch_tx, signal_tx) {
-                error!("Signal manager failed: {}", e);
+                error!("Signal manager failed: {e}");
             }
         });
 

sources/api/apiclient/src/exec.rs

@@ -43,7 +43,7 @@ impl Terminal {
                 let stdin_tty = isatty(STDIN_FILENO) == Ok(true);
                 let stdout_tty = isatty(STDOUT_FILENO) == Ok(true);
                 let is_tty = stdin_tty && stdout_tty;
-                debug!("Detected tty: {}", is_tty);
+                debug!("Detected tty: {is_tty}");
                 is_tty
             }
         };

sources/api/apiclient/src/exec/terminal.rs

@@ -893,7 +893,7 @@ async fn check(args: &Args) -> Result<String> {
     match serde_json::from_str::<serde_json::Value>(&output) {
         Ok(value) => println!("{value:#}"),
         Err(e) => {
-            warn!("Unable to deserialize response (invalid JSON?): {}", e);
+            warn!("Unable to deserialize response (invalid JSON?): {e}");
             println!("{output}");
         }
     }
@@ -907,7 +907,7 @@ async fn check(args: &Args) -> Result<String> {
 /// Main entry point, dispatches subcommands.
 async fn run() -> Result<()> {
     let (args, subcommand) = parse_args(env::args());
-    trace!("Parsed args for subcommand {:?}: {:?}", subcommand, args);
+    trace!("Parsed args for subcommand {subcommand:?}: {args:?}");
 
     // We use TerminalMode::Stderr because apiclient users expect server response data on stdout.
     TermLogger::init(
@@ -975,7 +975,7 @@ async fn run() -> Result<()> {
         Subcommand::Set(set) => {
             let settings = match set {
                 SetArgs::Simple(simple) => {
-                    trace!("User supplied Key Value settings {:#?}", simple);
+                    trace!("User supplied Key Value settings {simple:#?}");
                     // Construct the Key Pair struct.
                     let set_key_pair = SetKeyPairSettings {
                         request_payload: simple,
@@ -985,7 +985,7 @@ async fn run() -> Result<()> {
                     SettingsInput::KeyPair(settings_string)
                 }
                 SetArgs::Json(json) => {
-                    trace!("User supplied Json settings {:#?}", json);
+                    trace!("User supplied Json settings {json:#?}");
                     // Convert JSON Value to a string.
                     SettingsInput::Json(json.to_string())
                 }
@@ -1246,10 +1246,7 @@ mod tests {
                 assert_eq!(actual.tty, expected.tty);
                 assert_eq!(actual.command, expected.command);
             }
-            _ => panic!(
-                "Expected Exec subcommand: {:?}, got: {:?}",
-                expected_subcommand, subcommand
-            ),
+            _ => panic!("Expected Exec subcommand: {expected_subcommand:?}, got: {subcommand:?}"),
         }
     }
 
@@ -1293,10 +1290,7 @@ mod tests {
                 assert_eq!(actual.tty, expected.tty, "TTY setting should match");
                 assert_eq!(actual.command, expected.command, "Command should match");
             }
-            _ => panic!(
-                "Expected Exec subcommand: {:?}, got: {:?}",
-                expected_subcommand, subcommand
-            ),
+            _ => panic!("Expected Exec subcommand: {expected_subcommand:?}, got: {subcommand:?}"),
         }
     }
 }

sources/api/apiclient/src/main.rs

@@ -63,7 +63,7 @@ pub fn required(check_output: &str) -> bool {
             false
         }
         _ => {
-            debug!("Saw state '{}', assuming update is required", state);
+            debug!("Saw state '{state}', assuming update is required");
             true
         }
     }
@@ -202,7 +202,7 @@ where
         }
         .fail();
     };
-    debug!("Found initial timestamp '{}'", before_timestamp);
+    debug!("Found initial timestamp '{before_timestamp}'");
 
     // Make the real request the user wanted.
     let (_code, response_body) = raw_request(&socket_path, &url, &method, data)
@@ -258,10 +258,7 @@ where
             Ok((code, status_body)) => (code, status_body),
             Err(e) => {
                 failures += 1;
-                warn!(
-                    "Unable to check for update status, failure #{}: {}",
-                    failures, e
-                );
+                warn!("Unable to check for update status, failure #{failures}: {e}");
                 continue;
             }
         };
@@ -273,8 +270,7 @@ where
         } else if !code.is_success() {
             failures += 1;
             warn!(
-                "Got code {} when checking update status, failure #{}: {}",
-                code, failures, status_body
+                "Got code {code} when checking update status, failure #{failures}: {status_body}"
             );
             continue;
         }
@@ -284,8 +280,7 @@ where
             .unwrap_or_else(|| "missing".to_string());
         let after_command = response_field(&["most_recent_command", "cmd_type"], &status_body)
             .unwrap_or_else(|| "missing".to_string());
-        debug!("Found timestamp '{}' and command '{}' (looking for command '{}' and a change from initial timestamp '{}')",
-                after_timestamp, after_command, command_name, before_timestamp);
+        debug!("Found timestamp '{after_timestamp}' and command '{after_command}' (looking for command '{command_name}' and a change from initial timestamp '{before_timestamp}')");
 
         // If we have a new timestamp and see our expected command, we're done.
         // Note: we keep waiting if the timestamp changed but the command isn't what we expected;

sources/api/apiclient/src/update.rs

@@ -325,7 +325,7 @@ pub(crate) fn get_settings_keys<D: DataStore>(
 ) -> Result<Settings> {
     let mut data = HashMap::new();
     for key_str in keys {
-        trace!("Pulling value from datastore for key: {}", key_str);
+        trace!("Pulling value from datastore for key: {key_str}");
         let key = Key::new(KeyType::Data, key_str).context(error::NewKeySnafu {
             key_type: "data",
             name: *key_str,
@@ -445,10 +445,7 @@ pub(crate) fn set_settings<D: DataStore>(
             })?;
     }
 
-    info!(
-        "Writing Settings to pending transaction in datastore: {:?}",
-        pairs
-    );
+    info!("Writing Settings to pending transaction in datastore: {pairs:?}");
     datastore
         .set_keys(&pairs, &pending)
         .context(error::DataStoreSnafu { op: "set_keys" })
@@ -470,7 +467,7 @@ pub(crate) fn get_metadata_for_data_keys<D: DataStore, S: AsRef<str>>(
 
     let mut result = HashMap::new();
     for data_key_str in data_key_strs {
-        trace!("Pulling metadata from datastore for key: {}", data_key_str);
+        trace!("Pulling metadata from datastore for key: {data_key_str}");
         let data_key = Key::new(KeyType::Data, data_key_str).context(error::NewKeySnafu {
             key_type: "data",
             name: *data_key_str,
@@ -597,9 +594,7 @@ pub(crate) fn get_settings_generator_metadata<D: DataStore, S: AsRef<str>>(
                 .context(error::DeserializeSettingsGeneratorSnafu)?;
 
             trace!(
-                "Getting the metadata for key {:?} with setting generator {:?}",
-                data_key,
-                setting_generator
+                "Getting the metadata for key {data_key:?} with setting generator {setting_generator:?}"
             );
             expand_setting_generator(datastore, &data_key, setting_generator, &mut result)?;
         }
@@ -761,7 +756,7 @@ where
     if let Some(keys_limit) = keys_limit {
         let keys_limit: Vec<&str> = keys_limit.iter().map(|s| s.as_ref()).collect();
         // Prepare input to config applier; it uses the changed keys to update the right config
-        trace!("Serializing the commit's changed keys: {:?}", keys_limit);
+        trace!("Serializing the commit's changed keys: {keys_limit:?}");
         let cmd_input =
             serde_json::to_string(&keys_limit).context(error::CommandSerializationSnafu {
                 given: "commit's changed keys",

sources/api/apiserver/src/server/controller.rs

@@ -71,18 +71,15 @@ pub fn initialize(fs: Option<Filesystem>, disks: Option<Vec<String>>) -> Result<
         }
     );
 
-    info!("initializing ephemeral storage disks={:?}", disks);
+    info!("initializing ephemeral storage disks={disks:?}");
     // with a single disk, there is no need to create the array
     let device_name = match disks.len() {
         1 => disks.first().expect("non-empty").clone(),
         _ => {
             let scan_output = mdadm_scan()?;
             // no previously configured array found, so construct a new one
             if scan_output.is_empty() {
-                info!(
-                    "creating array named {:?} from {:?}",
-                    RAID_DEVICE_NAME, disks
-                );
+                info!("creating array named {RAID_DEVICE_NAME:?} from {disks:?}");
                 mdadm_create(RAID_DEVICE_NAME, disks.iter().map(|x| x.as_str()).collect())?;
             }
             // Once it is built, it will be available in `/dev/md/`
@@ -92,13 +89,10 @@ pub fn initialize(fs: Option<Filesystem>, disks: Option<Vec<String>>) -> Result<
 
     let fs = fs.unwrap_or(Filesystem::Xfs);
     if !is_formatted(&device_name, &fs)? {
-        info!("formatting {:?} as {}", device_name, fs);
+        info!("formatting {device_name:?} as {fs}");
         format_device(&device_name, &fs)?;
     } else {
-        info!(
-            "{:?} is already formatted as {}, skipping format",
-            device_name, fs
-        );
+        info!("{device_name:?} is already formatted as {fs}, skipping format");
     }
 
     Ok(())
@@ -158,7 +152,7 @@ pub fn bind(variant: &str, dirs: Vec<String>) -> Result<()> {
     }
     std::fs::create_dir_all(mount_point).context(error::MkdirSnafu {})?;
 
-    info!("mounting {:?} as {:?}", device_name, mount_point);
+    info!("mounting {device_name:?} as {mount_point:?}");
     let output = Command::new(MOUNT)
         .args([
             OsString::from(device_name.clone()),
@@ -188,13 +182,13 @@ pub fn bind(variant: &str, dirs: Vec<String>) -> Result<()> {
         std::fs::create_dir_all(&mount_destination).context(error::MkdirSnafu {})?;
 
         if is_mounted(dir)? {
-            info!("skipping bind mount of {:?}, already mounted", dir);
+            info!("skipping bind mount of {dir:?}, already mounted");
             continue;
         }
         // call the equivalent of
         // mount --rbind /mnt/.ephemeral/._var_lib_kubelet /var/lib/kubelet
         let source_dir = OsString::from(&dir);
-        info!("binding {:?} to {:?}", source_dir, mount_destination);
+        info!("binding {source_dir:?} to {mount_destination:?}");
 
         let output = Command::new(MOUNT)
             .args([
@@ -216,7 +210,7 @@ pub fn bind(variant: &str, dirs: Vec<String>) -> Result<()> {
 
     for dir in dirs {
         let source_dir = OsString::from(&dir);
-        info!("sharing mounts for {:?}", source_dir);
+        info!("sharing mounts for {source_dir:?}");
         // mount --make-rshared /var/lib/kubelet
         let output = Command::new(MOUNT)
             .args([OsStr::new("--make-rshared"), &source_dir])

sources/api/apiserver/src/server/ephemeral_storage.rs

@@ -269,7 +269,7 @@ impl StreamHandler<Result<Message, ws::ProtocolError>> for WsExec {
 
             // This means the client is done with us; stop the actor.
             Ok(Message::Close(reason)) => {
-                info!("Client closed exec connection with reason: {:?}", reason);
+                info!("Client closed exec connection with reason: {reason:?}");
                 ctx.close(reason);
                 ctx.stop();
             }
@@ -285,7 +285,7 @@ impl StreamHandler<Result<Message, ws::ProtocolError>> for WsExec {
             Ok(Message::Nop) => {}
 
             Err(e) => {
-                error!("Stopping after receiving error message: {}", e);
+                error!("Stopping after receiving error message: {e}");
                 ctx.stop();
             }
         }

sources/api/apiserver/src/server/exec.rs

@@ -124,15 +124,15 @@ impl ChildHandles {
         // meaning no ANSI escapes are passed back and forth.
         command.env("TERM", "screen");
 
-        debug!("Spawning command for exec request: {:?}", command);
+        debug!("Spawning command for exec request: {command:?}");
         let mut child = command.spawn().context(error::SpawnSnafu)?;
 
         // `Command` returns pid as u32, but we want i32 to deal with nix.
         let pid_raw = i32::try_from(child.id())
             .ok()
             .context(error::InvalidPidSnafu { given: child.id() })?;
         let pid = Pid::from_raw(pid_raw);
-        debug!("Spawned child has pid {}", pid);
+        debug!("Spawned child has pid {pid}");
 
         // Work around partial move of 'init' into closure; not needed in Rust 2021?
         let tty = init.tty;
@@ -423,7 +423,7 @@ impl WriteToChild {
             // If we can't write to the child process, end the loop and drop the channel so the
             // WebSocket receiver knows we can't accept any more and it should close.
             if let Err(e) = file.write_all(&data) {
-                error!("Failed to write to child process: {}", e);
+                error!("Failed to write to child process: {e}");
                 break;
             }
 
@@ -576,7 +576,7 @@ impl ReadFromChild {
                     if e == Errno::EIO {
                         debug!("Child closed output");
                     } else {
-                        error!("Failed reading from child: {}", e);
+                        error!("Failed reading from child: {e}");
                     }
                     break;
                 }