twoliter: bump sdk to v0.79.0

Twoliter.lock

@@ -4,7 +4,7 @@ project-vendor = "Bottlerocket"
 
 [sdk]
 name = "bottlerocket-sdk"
-version = "0.78.0"
+version = "0.79.0"
 vendor = "bottlerocket"
-source = "public.ecr.aws/bottlerocket/bottlerocket-sdk:v0.78.0"
-digest = "6dm8z91Cwe5BgAudM4XlkWPaF88bspeLBrjZ38VhKUs="
+source = "public.ecr.aws/bottlerocket/bottlerocket-sdk:v0.79.0"
+digest = "B/dAUOA5VWlAWwbti5D/Q577BaupO87OqlcmQXiHvew="

Twoliter.toml

@@ -7,5 +7,5 @@ registry = "public.ecr.aws/bottlerocket"
 
 [sdk]
 name = "bottlerocket-sdk"
-version = "0.78.0"
+version = "0.79.0"
 vendor = "bottlerocket"

sources/api/apiserver/src/bin/apiserver.rs

@@ -154,7 +154,7 @@ async fn run() -> Result<()> {
     };
     info!(
         "Starting server at {} with {} thread{} and datastore at {}",
-        &args.socket_path, threads, threads_suffix, &args.datastore_path,
+        args.socket_path, threads, threads_suffix, args.datastore_path,
     );
 
     serve(

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

@@ -391,7 +391,7 @@ where
         let item_data = datastore
             .get_prefix(&item_prefix, committed)
             .with_context(|_| error::DataStoreSnafu {
-                op: format!("get_prefix '{}' for {:?}", &item_prefix, committed),
+                op: format!("get_prefix '{}' for {:?}", item_prefix, committed),
             })?;
 
         ensure!(
@@ -498,7 +498,7 @@ pub(crate) fn get_metadata_for_data_keys<D: DataStore, S: AsRef<str>>(
 // key is always before its successors.
 fn sort_metadata(metadata: HashMap<Key, HashMap<Key, String>>) -> Vec<(Key, HashMap<Key, String>)> {
     let mut metadata_sorted: Vec<_> = metadata.into_iter().collect();
-    metadata_sorted.sort_by(|(k1, _), (k2, _)| k1.segments().len().cmp(&k2.segments().len()));
+    metadata_sorted.sort_by_key(|(k1, _)| k1.segments().len());
     metadata_sorted.to_vec()
 }
 

sources/api/bootstrap-containers/src/main.rs

@@ -518,7 +518,7 @@ where
         // Continue to handle other bootstrap containers if we fail one
         if let Err(e) = handle_bootstrap_container(name, container_details) {
             failed += 1;
-            error!("Failed to handle bootstrap container '{}': {}", &name, e);
+            error!("Failed to handle bootstrap container '{}': {}", name, e);
         }
     }
 

sources/api/datastore/src/deserialization/pairs.rs

@@ -285,18 +285,18 @@ where
                     return None;
                 }
             };
-            trace!("Visiting key '{}', struct name '{}'", key, &struct_name);
+            trace!("Visiting key '{}', struct name '{}'", key, struct_name);
 
             // At the top level (None path) we start with struct_name as Key, otherwise append
             // struct_name.
-            trace!("Old path: {:?}", &self.path);
+            trace!("Old path: {:?}", self.path);
             let path = match self.path {
                 None => match Key::from_segments(KeyType::Data, &[&struct_name]) {
                     Ok(key) => key,
                     Err(e) => {
                         error!(
                             "Tried to construct invalid key from struct name '{}', skipping: {}",
-                            &struct_name, e
+                            struct_name, e
                         );
                         return None;
                     }
@@ -306,18 +306,18 @@ where
                     Err(e) => {
                         error!(
                             "Appending '{}' to existing key '{}' resulted in invalid key, skipping: {}",
-                            old_path, &struct_name, e
+                            old_path, struct_name, e
                         );
                         return None;
                     }
                 }
             };
-            trace!("New path: {}", &path);
+            trace!("New path: {}", path);
 
             if !segments.is_empty() {
                 if structs_done.contains(&struct_name) {
                     // We've handled this structure with a recursive call, so we're done.
-                    trace!("Already handled struct '{}', skipping", &struct_name);
+                    trace!("Already handled struct '{}', skipping", struct_name);
                     None
                 } else {
                     // Otherwise, mark it, and recurse.
@@ -332,13 +332,13 @@ where
                         // Remove the prefix - should always work, but log and skip the key otherwise
                         .filter_map(|new_key| new_key
                                     .strip_prefix(&struct_name)
-                                    .map_err(|e| error!("Key starting with segment '{}' couldn't remove it as prefix: {}", &struct_name, e)).ok())
+                                    .map_err(|e| error!("Key starting with segment '{}' couldn't remove it as prefix: {}", struct_name, e)).ok())
                         .collect();
 
                     // And here's what MapDeserializer expects, the key and deserializer for it
                     trace!(
                         "Recursing for struct '{}' with keys: {:?}",
-                        &struct_name,
+                        struct_name,
                         keys
                     );
                     Some((

sources/api/datastore/src/filesystem.rs

@@ -563,7 +563,7 @@ impl DataStore for FilesystemDataStore {
 
         // Pull out just the keys so we can log them and return them
         let pending_keys = pending_data.into_keys().collect();
-        debug!("Found pending keys: {:?}", &pending_keys);
+        debug!("Found pending keys: {:?}", pending_keys);
 
         // Delete pending from the filesystem, same as a commit
         let path = self.base_path(&pending);

sources/api/datastore/src/lib.rs

@@ -258,7 +258,7 @@ pub trait DataStore {
                 trace!(
                     "Pulling metadata '{}' from datastore for key: {}",
                     meta_key,
-                    &data_key
+                    data_key
                 );
                 let value = self
                     .get_metadata(&meta_key, &data_key, committed)?

sources/api/datastore/src/serialization/pairs.rs

@@ -349,7 +349,7 @@ impl ser::SerializeMap for Serializer<'_> {
         // meaning it's in quoted form.
         let key = Key::new(KeyType::Data, &key_str).map_err(|e| {
             error::InvalidKeySnafu {
-                msg: format!("serialized map key '{}' not valid as Key: {}", &key_str, e),
+                msg: format!("serialized map key '{}' not valid as Key: {}", key_str, e),
             }
             .into_error(NoSource)
         })?;
@@ -408,7 +408,7 @@ impl ser::SerializeStruct for Serializer<'_> {
             "Recursively serializing struct with new root '{}' from prefix '{:?}' and key '{}'",
             new_root,
             self.prefix,
-            &key
+            key
         );
         value.serialize(Serializer::new(self.output, Some(new_root)))
     }

sources/api/host-containers/src/main.rs

@@ -480,7 +480,7 @@ fn run() -> Result<()> {
         if is_container_affected(&changed_settings, name.as_ref()) {
             if let Err(e) = handle_host_container(name, image_details) {
                 failed += 1;
-                error!("Failed to handle host container '{}': {}", &name, e);
+                error!("Failed to handle host container '{}': {}", name, e);
             }
         }
     }

sources/api/schnauzer/src/helpers/mod.rs

@@ -384,7 +384,7 @@ pub fn join_node_taints(
 ) -> Result<(), RenderError> {
     trace!("Starting join_node_taints helper");
     let template_name = template_name(renderctx);
-    trace!("Template name: {}", &template_name);
+    trace!("Template name: {}", template_name);
 
     trace!("Number of params: {}", helper.params().len());
     check_param_count(helper, template_name, 1)?;
@@ -854,7 +854,7 @@ pub fn kube_reserve_memory(
 ) -> Result<(), RenderError> {
     trace!("Starting kube_reserve_memory helper");
     let template_name = template_name(renderctx);
-    trace!("Template name: {}", &template_name);
+    trace!("Template name: {}", template_name);
 
     trace!("Number of params: {}", helper.params().len());
     check_param_count(helper, template_name, 2)?;
@@ -921,7 +921,7 @@ pub fn kube_reserve_cpu(
 ) -> Result<(), RenderError> {
     trace!("Starting kube_reserve_cpu helper");
     let template_name = template_name(renderctx);
-    trace!("Template name: {}", &template_name);
+    trace!("Template name: {}", template_name);
 
     trace!("Number of params: {}", helper.params().len());
     check_param_count(helper, template_name, 1)?;
@@ -973,7 +973,7 @@ pub fn localhost_aliases(
     // To give context to our errors, get the template name, if available.
     trace!("Starting localhost_aliases helper");
     let template_name = template_name(renderctx);
-    trace!("Template name: {}", &template_name);
+    trace!("Template name: {}", template_name);
 
     // Check number of parameters, must be exactly three (IP version, hostname, hosts overrides)
     trace!("Number of params: {}", helper.params().len());
@@ -1091,7 +1091,7 @@ pub fn etc_hosts_entries(
     // To give context to our errors, get the template name, if available.
     trace!("Starting etc_hosts_entries helper");
     let template_name = template_name(renderctx);
-    trace!("Template name: {}", &template_name);
+    trace!("Template name: {}", template_name);
 
     // Check number of parameters, must be exactly one (hosts overrides)
     trace!("Number of params: {}", helper.params().len());
@@ -1156,7 +1156,7 @@ pub fn ecs_metadata_service_limits(
     // To give context to our errors, get the template name, if available.
     trace!("Starting ecs_metadata_service_limits helper");
     let template_name = template_name(renderctx);
-    trace!("Template name: {}", &template_name);
+    trace!("Template name: {}", template_name);
 
     // Check number of parameters, must be exactly two (metadata_service_rps and
     // metadata_service_burst)
@@ -1337,7 +1337,7 @@ pub fn oci_defaults(
     // To give context to our errors, get the template name (e.g. what file we are rendering), if available.
     debug!("Starting oci_defaults helper");
     let template_name = template_name(renderctx);
-    debug!("Template name: {}", &template_name);
+    debug!("Template name: {}", template_name);
 
     // Check number of parameters, must be exactly two (OCI spec section to render and settings values for the section)
     debug!("Number of params: {}", helper.params().len());

sources/api/schnauzer/src/helpers/stdlib/mod.rs

@@ -175,7 +175,7 @@ pub fn base64_decode(
     // To give context to our errors, get the template name, if available.
     trace!("Starting base64_decode helper");
     let template_name = template_name(renderctx);
-    trace!("Template name: {}", &template_name);
+    trace!("Template name: {}", template_name);
 
     // Check number of parameters, must be exactly one
     trace!("Number of params: {}", helper.params().len());
@@ -298,7 +298,7 @@ pub fn join_map(
 ) -> Result<(), RenderError> {
     trace!("Starting join_map helper");
     let template_name = template_name(renderctx);
-    trace!("Template name: {}", &template_name);
+    trace!("Template name: {}", template_name);
 
     trace!("Number of params: {}", helper.params().len());
     check_param_count(helper, template_name, 4)?;
@@ -523,7 +523,7 @@ pub fn default(
 ) -> Result<(), RenderError> {
     trace!("Starting default helper");
     let template_name = template_name(renderctx);
-    trace!("Template name: {}", &template_name);
+    trace!("Template name: {}", template_name);
 
     trace!("Number of params: {}", helper.params().len());
     check_param_count(helper, template_name, 2)?;
@@ -685,7 +685,7 @@ impl HelperDef for IfNotNullHelper {
     ) -> Result<(), RenderError> {
         trace!("Starting if_not_null helper");
         let template_name = template_name(renderctx);
-        trace!("Template name: {}", &template_name);
+        trace!("Template name: {}", template_name);
 
         trace!("Number of params: {}", helper.params().len());
         check_param_count(helper, template_name, 1)?;
@@ -1033,7 +1033,7 @@ pub fn negate_or_else(
     // To give context to our errors, get the template name, if available.
     trace!("Starting negate_or_else helper");
     let template_name = template_name(renderctx);
-    trace!("Template name: {}", &template_name);
+    trace!("Template name: {}", template_name);
 
     // Check number of parameters, must be exactly two (the value to negate and the default value)
     trace!("Number of params: {}", helper.params().len());

sources/api/settings-committer/src/main.rs

@@ -77,7 +77,7 @@ async fn check_pending_settings<S: AsRef<str>>(socket_path: S, transaction: &str
         serde_json::from_str(&response_body);
     match pending_result {
         Ok(pending) => {
-            debug!("Pending settings for tx {}: {:?}", transaction, &pending);
+            debug!("Pending settings for tx {}: {:?}", transaction, pending);
         }
         Err(err) => {
             warn!("Failed to parse response from {uri}: {err}");

sources/api/shibaken/src/admin_userdata.rs

@@ -22,7 +22,7 @@ impl GenerateAdminUserdata {
         // Serialize user_data to a JSON string that can be read by the admin container.
         let user_data_json =
             serde_json::to_string(&user_data).context(error::SerializeJsonSnafu)?;
-        log::debug!("{}", &user_data_json);
+        log::debug!("{}", user_data_json);
 
         log::info!("Encoding user-data");
         // admin container user-data must be base64-encoded to be passed through to the admin container

sources/api/shibaken/src/warmpool/autoscaling_warm_pool.rs

@@ -32,7 +32,7 @@ impl WarmPoolWait {
 
         fs::write(&marker_file_path, "").unwrap_or_else(|e| {
             log::warn!("Failed to create marker file '{}', warm-pool-wait service may unexpectedly run again: '{}'",
-            &marker_file_path, e);
+            marker_file_path, e);
         });
         println!("Marker file path is {marker_file_path}");
 

sources/api/storewolf/src/main.rs

@@ -181,14 +181,14 @@ fn parse_metadata_toml(md_toml_val: toml::Value) -> Result<Vec<model::Metadata>>
     let mut to_process = vec![(Vec::new(), md_toml_val)];
 
     while let Some((mut path, toml_value)) = to_process.pop() {
-        trace!("Current metadata table path: {:#?}", &path);
+        trace!("Current metadata table path: {:#?}", path);
 
         match toml_value {
             // A table means there is more processing to do. Add the current
             // key and value to the Vec to be processed further.
             toml::Value::Table(table) => {
                 for (key, val) in table {
-                    trace!("Found table for key '{}'", &key);
+                    trace!("Found table for key '{}'", key);
                     let mut path = path.clone();
                     if key == "setting-generator" {
                         match val {
@@ -203,8 +203,8 @@ fn parse_metadata_toml(md_toml_val: toml::Value) -> Result<Vec<model::Metadata>>
 
                                 trace!(
                                     "Found metadata key '{}' for data key '{}'",
-                                    &md_key,
-                                    &data_key
+                                    md_key,
+                                    data_key
                                 );
 
                                 // Ensure the metadata/data keys don't contain newline chars
@@ -245,8 +245,8 @@ fn parse_metadata_toml(md_toml_val: toml::Value) -> Result<Vec<model::Metadata>>
 
                 trace!(
                     "Found metadata key '{}' for data key '{}'",
-                    &md_key,
-                    &data_key
+                    md_key,
+                    data_key
                 );
 
                 // Ensure the metadata/data keys don't contain newline chars
@@ -297,7 +297,7 @@ fn populate_default_datastore<P: AsRef<Path>>(
             .list_populated_keys("", &Committed::Live)
             .context(error::QueryDataSnafu)?;
     } else {
-        info!("Creating datastore at: {}", &live_path.display());
+        info!("Creating datastore at: {}", live_path.display());
         create_new_datastore(&base_path, version).context(error::DatastoreCreationSnafu)?;
     }
 
@@ -345,7 +345,7 @@ fn populate_default_datastore<P: AsRef<Path>>(
 
         trace!(
             "Writing other default data to datastore: {:#?}",
-            &other_defaults_to_write
+            other_defaults_to_write
         );
         datastore
             .set_keys(&other_defaults_to_write, &datastore::Committed::Live)
@@ -392,7 +392,7 @@ fn populate_default_data(
 
         trace!(
             "Writing default settings to datastore: {:#?}",
-            &settings_to_write
+            settings_to_write
         );
         let pending = datastore::Committed::Pending {
             tx: constants::LAUNCH_TRANSACTION.to_string(),
@@ -614,14 +614,14 @@ fn run() -> Result<()> {
     }
 
     // Create the datastore if it doesn't exist
-    info!("Populating datastore at: {}", &args.data_store_base_path);
+    info!("Populating datastore at: {}", args.data_store_base_path);
     populate_default_datastore(&args.data_store_base_path, args.version)?;
     info!("Datastore populated");
 
     // Create the inventory file symlink and any necessary parent directories
     info!(
         "Creating inventory file symlink at: {}",
-        &args.inventory_symlink_path
+        args.inventory_symlink_path
     );
     create_inventory_symlink(&args.inventory_file_path, &args.inventory_symlink_path)?;
     info!("Inventory symlink created");