Clippy.

rs/ic-observability/multiservice-discovery/src/server_handlers/add_boundary_node_to_definition_handler.rs

@@ -16,13 +16,15 @@ pub struct AddBoundaryNodeToDefinitionBinding {
 
 #[derive(Debug)]
 
-struct DefinitionNotFound(String);
+struct DefinitionNotFound {
+    ic_name: String,
+}
 
 impl Error for DefinitionNotFound {}
 
 impl Display for DefinitionNotFound {
     fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
-        write!(f, "definition {} not found", self)
+        write!(f, "definition {} not found", self.ic_name)
     }
 }
 
@@ -33,12 +35,13 @@ pub(crate) async fn add_boundary_node(
     let log = binding.log.clone();
     let name = boundary_node.name.clone();
     let ic_name = boundary_node.ic_name.clone();
+    let rej: String = format!("Definition {} could not be added", name);
+
     let mut definitions = binding.supervisor.definitions.lock().await;
-    let rej = format!("Definition {} could not be added", name);
 
     let running_definition = match definitions.get_mut(&ic_name) {
         Some(d) => d,
-        None => return not_found(log, rej, DefinitionNotFound(ic_name)),
+        None => return not_found(log, rej, DefinitionNotFound { ic_name }),
     };
 
     let bn = match boundary_node.try_into_boundary_node() {
@@ -48,6 +51,6 @@ pub(crate) async fn add_boundary_node(
 
     match running_definition.add_boundary_node(bn).await {
         Ok(()) => ok(log, format!("Definition {} added successfully", name)),
-        Err(e) => return bad_request(log, rej, e),
+        Err(e) => bad_request(log, rej, e),
     }
 }

rs/ic-observability/multiservice-discovery/src/server_handlers/add_definition_handler.rs

@@ -36,6 +36,6 @@ pub(crate) async fn add_definition(definition: DefinitionDto, binding: AddDefini
     };
     match binding.supervisor.start(vec![new_definition], false).await {
         Ok(()) => ok(log, format!("Definition {} added successfully", dname)),
-        Err(e) => return bad_request(log, rej, e.errors.into_iter().next().unwrap()),
+        Err(e) => bad_request(log, rej, e.errors.into_iter().next().unwrap()),
     }
 }

rs/ic-observability/multiservice-discovery/src/server_handlers/replace_definitions_handler.rs

@@ -34,9 +34,8 @@ pub(crate) async fn replace_definitions(
         .collect();
     let defsresults: Vec<Result<Definition, BadDtoError>> = join_all(defsresults_futures).await;
     let (new_definitions, errors): (Vec<_>, Vec<_>) = defsresults.into_iter().partition(Result::is_ok);
-    let new_definitions: Vec<_> = new_definitions.into_iter().map(Result::unwrap).collect();
-    let errors: Vec<_> = errors.into_iter().map(Result::unwrap_err).collect();
 
+    let errors: Vec<_> = errors.into_iter().map(Result::unwrap_err).collect();
     if !errors.is_empty() {
         return bad_request(
             log,
@@ -48,6 +47,7 @@ pub(crate) async fn replace_definitions(
         );
     }
 
+    let new_definitions: Vec<_> = new_definitions.into_iter().map(Result::unwrap).collect();
     match binding.supervisor.start(new_definitions, true).await {
         Ok(_) => ok(log, format!("Added new definitions {} to existing ones", dnames)),
         Err(e) => bad_request(log, rej, format!(":\n{}", e)),