fix: Update logging

Adds additional `std::fmt::Debug` implementations, these require
removing some dynamic which involves removing the `BusDevice`
trait.

Signed-off-by: Jonathan Woollett-Light <[email protected]>

Author: Jonathan Woollett-Light

Cargo.lock

@@ -10,6 +10,7 @@
 mod parsed_request;
 mod request;
 
+use std::fmt::Debug;
 use std::path::PathBuf;
 use std::sync::mpsc;
 
@@ -44,6 +45,7 @@ pub enum Error {
 type Result<T> = std::result::Result<T, Error>;
 
 /// Structure associated with the API server implementation.
+#[derive(Debug)]
 pub struct ApiServer {
     /// Sender which allows passing messages to the VMM.
     api_request_sender: mpsc::Sender<ApiRequest>,
@@ -225,7 +227,7 @@ impl ApiServer {
         request: &Request,
         request_processing_start_us: u64,
     ) -> Response {
-        match ParsedRequest::try_from_request(request).map(|r| r.into_parts()) {
+        match ParsedRequest::try_from(request).map(|r| r.into_parts()) {
             Ok((req_action, mut parsing_info)) => {
                 let mut response = match req_action {
                     RequestAction::Sync(vmm_action) => {
@@ -291,13 +293,13 @@ impl ApiServer {
     }
 
     /// An HTTP response which also includes a body.
-    pub(crate) fn json_response<T: Into<String>>(status: StatusCode, body: T) -> Response {
+    pub(crate) fn json_response<T: Into<String> + Debug>(status: StatusCode, body: T) -> Response {
         let mut response = Response::new(Version::Http11, status);
         response.set_body(Body::new(body.into()));
         response
     }
 
-    fn json_fault_message<T: AsRef<str> + serde::Serialize>(msg: T) -> String {
+    fn json_fault_message<T: AsRef<str> + serde::Serialize + Debug>(msg: T) -> String {
         json!({ "fault_message": msg }).to_string()
     }
 }

src/api_server/src/lib.rs

@@ -1,6 +1,8 @@
 // Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::fmt::Debug;
+
 use logger::{error, info, log_enabled, Level};
 use micro_http::{Body, Method, Request, Response, StatusCode, Version};
 use serde::ser::Serialize;
@@ -27,14 +29,13 @@ use crate::request::version::parse_get_version;
 use crate::request::vsock::parse_put_vsock;
 use crate::ApiServer;
 
-#[cfg_attr(test, derive(Debug))]
+#[derive(Debug)]
 pub(crate) enum RequestAction {
     Sync(Box<VmmAction>),
     ShutdownInternal, // !!! not an API, used by shutdown to thread::join the API thread
 }
 
-#[derive(Default)]
-#[cfg_attr(test, derive(Debug, PartialEq))]
+#[derive(Debug, Default, PartialEq)]
 pub(crate) struct ParsingInfo {
     deprecation_message: Option<String>,
 }
@@ -52,7 +53,7 @@ impl ParsingInfo {
     }
 }
 
-#[cfg_attr(test, derive(Debug))]
+#[derive(Debug)]
 pub(crate) struct ParsedRequest {
     action: RequestAction,
     parsing_info: ParsingInfo,
@@ -141,7 +142,7 @@ impl ParsedRequest {
 
     pub(crate) fn success_response_with_data<T>(body_data: &T) -> Response
     where
-        T: ?Sized + Serialize,
+        T: ?Sized + Serialize + Debug,
     {
         info!("The request was executed successfully. Status code: 200 OK.");
         let mut response = Response::new(Version::Http11, StatusCode::OK);

src/api_server/src/parsed_request.rs

@@ -9,7 +9,7 @@ pub mod dump;
 
 macro_rules! declare_fingerprint_struct_and_enum {
     ($($field_name:ident : $field_type:ty),+) => {
-        #[derive(Serialize, Deserialize)]
+        #[derive(Debug, Serialize, Deserialize)]
         pub struct Fingerprint {
             $(pub $field_name: $field_type),+
         }

src/cpu-template-helper/src/fingerprint/mod.rs

@@ -37,14 +37,14 @@ enum Error {
 
 type Result<T> = std::result::Result<T, Error>;
 
-#[derive(Parser)]
+#[derive(Debug, Parser)]
 #[command(version = format!("v{}", crate::utils::CPU_TEMPLATE_HELPER_VERSION))]
 struct Cli {
     #[command(subcommand)]
     command: Command,
 }
 
-#[derive(Subcommand)]
+#[derive(Debug, Subcommand)]
 enum Command {
     /// Template-related operations
     #[command(subcommand)]
@@ -54,7 +54,7 @@ enum Command {
     Fingerprint(FingerprintOperation),
 }
 
-#[derive(Subcommand)]
+#[derive(Debug, Subcommand)]
 enum TemplateOperation {
     /// Dump guest CPU configuration in the custom CPU template format.
     Dump {
@@ -82,7 +82,7 @@ enum TemplateOperation {
     },
 }
 
-#[derive(Subcommand)]
+#[derive(Debug, Subcommand)]
 enum FingerprintOperation {
     /// Dump fingerprint consisting of host-related information and guest CPU config.
     Dump {

src/cpu-template-helper/src/main.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use std::collections::HashMap;
+use std::fmt::Debug;
 
 use crate::utils::{ModifierMapKey, ModifierMapValue};
 
@@ -24,8 +25,8 @@ pub enum Error {
 
 fn strip_common<K, V>(maps: &mut [HashMap<K, V>]) -> Result<(), Error>
 where
-    K: ModifierMapKey,
-    V: ModifierMapValue,
+    K: ModifierMapKey + Debug,
+    V: ModifierMapValue + Debug,
 {
     if maps.len() < 2 {
         return Err(Error::NumberOfInputs);

src/cpu-template-helper/src/template/strip/mod.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use std::collections::HashMap;
+use std::fmt::Debug;
 
 use crate::utils::{ModifierMapKey, ModifierMapValue};
 
@@ -31,8 +32,8 @@ pub enum Error {
 /// respectively before calling this arch-agnostic function.
 pub fn verify_common<K, V>(template: HashMap<K, V>, config: HashMap<K, V>) -> Result<(), Error>
 where
-    K: ModifierMapKey,
-    V: ModifierMapValue,
+    K: ModifierMapKey + Debug,
+    V: ModifierMapValue + Debug,
 {
     for (key, template_value_filter) in template {
         let config_value_filter = config

src/cpu-template-helper/src/template/verify/mod.rs

@@ -48,17 +48,19 @@ impl ByteBuffer for [u8] {
 
 #[cfg(test)]
 mod tests {
+    use std::fmt::Debug;
+
     use super::*;
 
-    fn bb_len<T: ByteBuffer + ?Sized>(buf: &T) -> usize {
+    fn bb_len<T: ByteBuffer + ?Sized + Debug>(buf: &T) -> usize {
         buf.len()
     }
 
-    fn bb_is_empty<T: ByteBuffer + ?Sized>(buf: &T) -> bool {
+    fn bb_is_empty<T: ByteBuffer + ?Sized + Debug>(buf: &T) -> bool {
         buf.len() == 0
     }
 
-    fn bb_read_from_1<T: ByteBuffer + ?Sized>(src: &T, dst: &mut [u8]) {
+    fn bb_read_from_1<T: ByteBuffer + ?Sized + Debug>(src: &T, dst: &mut [u8]) {
         src.read_to_slice(1, dst);
     }
 

src/dumbo/src/lib.rs

@@ -8,6 +8,7 @@
 //!
 //! [here]: https://en.wikipedia.org/wiki/Address_Resolution_Protocol
 use std::convert::From;
+use std::fmt::Debug;
 use std::net::Ipv4Addr;
 use std::result::Result;
 
@@ -65,12 +66,13 @@ pub enum Error {
 /// ARP is a generic protocol as far as data
 /// link layer and network layer protocols go, but this particular implementation is concerned with
 /// ARP frames related to IPv4 over Ethernet.
+#[derive(Debug)]
 pub struct EthIPv4ArpFrame<'a, T: 'a> {
     bytes: InnerBytes<'a, T>,
 }
 
 #[allow(clippy::len_without_is_empty)]
-impl<'a, T: NetworkBytes> EthIPv4ArpFrame<'a, T> {
+impl<'a, T: NetworkBytes + Debug> EthIPv4ArpFrame<'a, T> {
     /// Interprets the given bytes as an ARP frame, without doing any validity checks beforehand.
     ///
     ///  # Panics
@@ -183,7 +185,7 @@ impl<'a, T: NetworkBytes> EthIPv4ArpFrame<'a, T> {
     }
 }
 
-impl<'a, T: NetworkBytesMut> EthIPv4ArpFrame<'a, T> {
+impl<'a, T: NetworkBytesMut + Debug> EthIPv4ArpFrame<'a, T> {
     #[allow(clippy::too_many_arguments)]
     fn write_raw(
         buf: T,
@@ -338,23 +340,17 @@ pub fn test_speculative_tpa(buf: &[u8], addr: Ipv4Addr) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use std::fmt;
+    use std::str::FromStr;
 
     use super::*;
 
-    impl<'a, T: NetworkBytes> fmt::Debug for EthIPv4ArpFrame<'a, T> {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            write!(f, "(EthIPv4ArpFrame frame)")
-        }
-    }
-
     #[test]
     fn test_eth_ipv4_arp_frame() {
         let mut a = [0u8; 1000];
         let mut bad_array = [0u8; 1];
 
-        let sha = MacAddr::parse_str("01:23:45:67:89:ab").unwrap();
-        let tha = MacAddr::parse_str("cd:ef:01:23:45:67").unwrap();
+        let sha = MacAddr::from_str("01:23:45:67:89:ab").unwrap();
+        let tha = MacAddr::from_str("cd:ef:01:23:45:67").unwrap();
         let spa = Ipv4Addr::new(10, 1, 2, 3);
         let tpa = Ipv4Addr::new(10, 4, 5, 6);
 

src/dumbo/src/pdu/arp.rs

@@ -64,6 +64,7 @@
 //! read/write goes beyond the boundaries of a slice. Callers must take the necessary precautions
 //! to avoid panics.
 
+use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 
@@ -151,12 +152,13 @@ impl<'a> NetworkBytesMut for &'a mut [u8] {}
 // This struct is used as a convenience for any type which contains a generic member implementing
 // NetworkBytes with a lifetime, so we don't have to also add the PhantomData member each time. We
 // use pub(super) here because we only want this to be usable by the child modules of `pdu`.
+#[derive(Debug)]
 pub(super) struct InnerBytes<'a, T: 'a> {
     bytes: T,
     phantom: PhantomData<&'a T>,
 }
 
-impl<'a, T> InnerBytes<'a, T> {
+impl<'a, T: Debug> InnerBytes<'a, T> {
     /// Creates a new instance as a wrapper around `bytes`.
     #[inline]
     pub fn new(bytes: T) -> Self {
@@ -167,7 +169,7 @@ impl<'a, T> InnerBytes<'a, T> {
     }
 }
 
-impl<'a, T: Deref<Target = [u8]>> Deref for InnerBytes<'a, T> {
+impl<'a, T: Deref<Target = [u8]> + Debug> Deref for InnerBytes<'a, T> {
     type Target = [u8];
 
     #[inline]
@@ -176,21 +178,21 @@ impl<'a, T: Deref<Target = [u8]>> Deref for InnerBytes<'a, T> {
     }
 }
 
-impl<'a, T: DerefMut<Target = [u8]>> DerefMut for InnerBytes<'a, T> {
+impl<'a, T: DerefMut<Target = [u8]> + Debug> DerefMut for InnerBytes<'a, T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut [u8] {
         self.bytes.deref_mut()
     }
 }
 
-impl<'a, T: NetworkBytes> NetworkBytes for InnerBytes<'a, T> {
+impl<'a, T: NetworkBytes + Debug> NetworkBytes for InnerBytes<'a, T> {
     #[inline]
     fn shrink_unchecked(&mut self, len: usize) {
         self.bytes.shrink_unchecked(len);
     }
 }
 
-impl<'a, T: NetworkBytesMut> NetworkBytesMut for InnerBytes<'a, T> {}
+impl<'a, T: NetworkBytesMut + Debug> NetworkBytesMut for InnerBytes<'a, T> {}
 
 #[cfg(test)]
 mod tests {