defmt::Format implementations for types forgotten during the first pass

Author: ivmarkov

.github/workflows/ci.yml

@@ -48,3 +48,5 @@ jobs:
         run: cargo build --no-default-features --features embassy,defmt
       - name: Build | Examples
         run: cargo build --examples --features log
+      - name: Build | Examples - defmt
+        run: export DEFMT_LOG=trace; cargo check --examples --features std,defmt

Cargo.toml

@@ -50,47 +50,47 @@ async-compat = "0.2" # For the `mqtt_client` example
 
 [[example]]
 name = "captive_portal"
-required-features = ["std", "log"]
+required-features = ["std"]
 
 [[example]]
 name = "dhcp_client"
-required-features = ["std", "log"]
+required-features = ["std"]
 
 [[example]]
 name = "dhcp_server"
-required-features = ["std", "log"]
+required-features = ["std"]
 
 [[example]]
 name = "http_client"
-required-features = ["std", "log"]
+required-features = ["std"]
 
 [[example]]
 name = "http_server"
-required-features = ["std", "log"]
+required-features = ["std"]
 
 [[example]]
 name = "mdns_responder"
-required-features = ["std", "log"]
+required-features = ["std"]
 
 [[example]]
 name = "mdns_service_responder"
-required-features = ["std", "log"]
+required-features = ["std"]
 
 [[example]]
 name = "ws_client"
-required-features = ["std", "log"]
+required-features = ["std"]
 
 [[example]]
 name = "ws_server"
-required-features = ["std", "log"]
+required-features = ["std"]
 
 [[example]]
 name = "nal_std"
-required-features = ["std", "log"]
+required-features = ["std"]
 
 [[example]]
 name = "mqtt_client"
-required-features = ["std", "embedded-svc", "log"]
+required-features = ["std", "embedded-svc"]
 
 [workspace]
 members = [

edge-captive/src/lib.rs

@@ -87,7 +87,7 @@ pub fn reply(
     let buf = Buf(buf, 0);
 
     let message = domain::base::Message::from_octets(request)?;
-    debug!("Processing message with header: {:?}", message.header());
+    debug!("Processing message with header: {:?}", debug2format!(message.header()));
 
     let mut responseb = domain::base::MessageBuilder::from_target(buf)?;
 
@@ -106,10 +106,10 @@ pub fn reply(
                     Ttl::from_duration_lossy(ttl),
                     A::from_octets(ip[0], ip[1], ip[2], ip[3]),
                 );
-                debug!("Answering {:?} with {:?}", question, record);
+                debug!("Answering {:?} with {:?}", debug2format!(question), debug2format!(record));
                 answerb.push(record)?;
             } else {
-                debug!("Question {:?} is not of type A, not answering", question);
+                debug!("Question {:?} is not of type A, not answering", debug2format!(question));
             }
         }
 

edge-http/src/io.rs

@@ -116,6 +116,29 @@ where
     }
 }
 
+#[cfg(feature = "defmt")]
+impl<E> defmt::Format for Error<E>
+where
+    E: defmt::Format,
+{
+    fn format(&self, f: defmt::Formatter<'_>) {
+        match self {
+            Self::InvalidHeaders => defmt::write!(f, "Invalid HTTP headers or status line"),
+            Self::InvalidBody => defmt::write!(f, "Invalid HTTP body"),
+            Self::TooManyHeaders => defmt::write!(f, "Too many HTTP headers"),
+            Self::TooLongHeaders => defmt::write!(f, "HTTP headers section is too long"),
+            Self::TooLongBody => defmt::write!(f, "HTTP body is too long"),
+            Self::IncompleteHeaders => defmt::write!(f, "HTTP headers section is incomplete"),
+            Self::IncompleteBody => defmt::write!(f, "HTTP body is incomplete"),
+            Self::InvalidState => defmt::write!(f, "Connection is not in requested state"),
+            Self::HeadersMismatchError(e) => defmt::write!(f, "Headers mismatch: {}", e),
+            Self::WsUpgradeError(e) => defmt::write!(f, "WebSocket upgrade error: {}", e),
+            Self::ConnectionClosed => defmt::write!(f, "Connection closed"),
+            Self::Io(e) => defmt::write!(f, "{}", e),
+        }
+    }
+}
+
 #[cfg(feature = "std")]
 impl<E> std::error::Error for Error<E> where E: std::error::Error {}
 

edge-http/src/io/server.rs

@@ -332,6 +332,7 @@ where
 }
 
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum HandlerError<T, E> {
     Io(T),
     Connection(Error<T>),
@@ -466,22 +467,25 @@ pub async fn handle_connection<H, T, const N: usize>(
     T: Read + Write + Readable + TcpSplit + TcpShutdown,
 {
     let close = loop {
-        debug!("Handler task {}: Waiting for a new request", task_id);
+        debug!(
+            "Handler task {}: Waiting for a new request",
+            display2format!(task_id)
+        );
 
         if let Some(keepalive_timeout_ms) = keepalive_timeout_ms {
             let wait_data = with_timeout(keepalive_timeout_ms, io.readable()).await;
             match wait_data {
                 Err(WithTimeoutError::Timeout) => {
                     info!(
                         "Handler task {}: Closing connection due to inactivity",
-                        task_id
+                        display2format!(task_id)
                     );
                     break true;
                 }
                 Err(e) => {
                     warn!(
                         "Handler task {}: Error when handling request: {:?}",
-                        task_id, e
+                        display2format!(task_id), debug2format!(e)
                     );
                     break true;
                 }
@@ -493,25 +497,32 @@ pub async fn handle_connection<H, T, const N: usize>(
 
         match result {
             Err(HandlerError::Connection(Error::ConnectionClosed)) => {
-                debug!("Handler task {}: Connection closed", task_id);
+                debug!(
+                    "Handler task {}: Connection closed",
+                    display2format!(task_id)
+                );
                 break false;
             }
             Err(e) => {
                 warn!(
                     "Handler task {}: Error when handling request: {:?}",
-                    task_id, e
+                    display2format!(task_id),
+                    debug2format!(e)
                 );
                 break true;
             }
             Ok(needs_close) => {
                 if needs_close {
                     debug!(
                         "Handler task {}: Request complete; closing connection",
-                        task_id
+                        display2format!(task_id)
                     );
                     break true;
                 } else {
-                    debug!("Handler task {}: Request complete", task_id);
+                    debug!(
+                        "Handler task {}: Request complete",
+                        display2format!(task_id)
+                    );
                 }
             }
         }
@@ -521,7 +532,8 @@ pub async fn handle_connection<H, T, const N: usize>(
         if let Err(e) = io.close(Close::Both).await {
             warn!(
                 "Handler task {}: Error when closing the socket: {:?}",
-                task_id, e
+                display2format!(task_id),
+                debug2format!(e)
             );
         }
     } else {
@@ -557,6 +569,20 @@ where
     }
 }
 
+#[cfg(feature = "defmt")]
+impl<C, E> defmt::Format for HandleRequestError<C, E>
+where
+    C: defmt::Format,
+    E: defmt::Format,
+{
+    fn format(&self, f: defmt::Formatter<'_>) {
+        match self {
+            Self::Connection(e) => defmt::write!(f, "Connection error: {}", e),
+            Self::Handler(e) => defmt::write!(f, "Handler error: {}", e),
+        }
+    }
+}
+
 impl<C, E> embedded_io_async::Error for HandleRequestError<C, E>
 where
     C: Debug + embedded_io_async::Error,
@@ -690,15 +716,21 @@ impl<const P: usize, const B: usize, const N: usize> Server<P, B, N> {
             unwrap!(tasks
                 .push(async move {
                     loop {
-                        debug!("Handler task {}: Waiting for connection", task_id);
+                        debug!(
+                            "Handler task {}: Waiting for connection",
+                            display2format!(task_id)
+                        );
 
                         let io = {
                             let _guard = mutex.lock().await;
 
                             acceptor.accept().await.map_err(Error::Io)?.1
                         };
 
-                        debug!("Handler task {}: Got connection request", task_id);
+                        debug!(
+                            "Handler task {}: Got connection request",
+                            display2format!(task_id)
+                        );
 
                         handle_connection::<_, _, N>(
                             io,
@@ -715,7 +747,7 @@ impl<const P: usize, const B: usize, const N: usize> Server<P, B, N> {
 
         let (result, _) = embassy_futures::select::select_slice(&mut tasks).await;
 
-        warn!("Server processing loop quit abruptly: {:?}", result);
+        warn!("Server processing loop quit abruptly: {:?}", debug2format!(result));
 
         result
     }

edge-http/src/lib.rs

@@ -45,6 +45,19 @@ impl Display for HeadersMismatchError {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for HeadersMismatchError {
+    fn format(&self, f: defmt::Formatter<'_>) {
+        match self {
+            Self::ResponseConnectionTypeMismatchError => defmt::write!(
+                f,
+                "Response connection type is different from the request connection type"
+            ),
+            Self::BodyTypeError(s) => defmt::write!(f, "Body type mismatch: {}", s),
+        }
+    }
+}
+
 /// Http methods
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "std", derive(Hash))]
@@ -202,6 +215,13 @@ impl Display for Method {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for Method {
+    fn format(&self, f: defmt::Formatter<'_>) {
+        defmt::write!(f, "{}", self.as_str())
+    }
+}
+
 /// HTTP headers
 #[derive(Debug)]
 pub struct Headers<'b, const N: usize = 64>([httparse::Header<'b>; N]);
@@ -565,6 +585,17 @@ impl Display for ConnectionType {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for ConnectionType {
+    fn format(&self, f: defmt::Formatter<'_>) {
+        match self {
+            Self::KeepAlive => defmt::write!(f, "Keep-Alive"),
+            Self::Close => defmt::write!(f, "Close"),
+            Self::Upgrade => defmt::write!(f, "Upgrade"),
+        }
+    }
+}
+
 /// Body type
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub enum BodyType {
@@ -734,6 +765,17 @@ impl Display for BodyType {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for BodyType {
+    fn format(&self, f: defmt::Formatter<'_>) {
+        match self {
+            Self::Chunked => defmt::write!(f, "Chunked"),
+            Self::ContentLen(len) => defmt::write!(f, "Content-Length: {}", len),
+            Self::Raw => defmt::write!(f, "Raw"),
+        }
+    }
+}
+
 /// Request headers including the request line (method, path)
 #[derive(Debug)]
 pub struct RequestHeaders<'b, const N: usize> {
@@ -790,6 +832,23 @@ impl<const N: usize> Display for RequestHeaders<'_, N> {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl<const N: usize> defmt::Format for RequestHeaders<'_, N> {
+    fn format(&self, f: defmt::Formatter<'_>) {
+        defmt::write!(f, "{} ", if self.http11 { "HTTP/1.1" } else { "HTTP/1.0" });
+
+        defmt::write!(f, "{} {}\n", self.method, self.path);
+
+        for (name, value) in self.headers.iter() {
+            if name.is_empty() {
+                break;
+            }
+
+            defmt::write!(f, "{}: {}\n", name, value);
+        }
+    }
+}
+
 /// Response headers including the response line (HTTP version, status code, reason phrase)
 #[derive(Debug)]
 pub struct ResponseHeaders<'b, const N: usize> {
@@ -851,6 +910,23 @@ impl<const N: usize> Display for ResponseHeaders<'_, N> {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl<const N: usize> defmt::Format for ResponseHeaders<'_, N> {
+    fn format(&self, f: defmt::Formatter<'_>) {
+        defmt::write!(f, "{} ", if self.http11 { "HTTP/1.1 " } else { "HTTP/1.0" });
+
+        defmt::write!(f, "{} {}\n", self.code, self.reason.unwrap_or(""));
+
+        for (name, value) in self.headers.iter() {
+            if name.is_empty() {
+                break;
+            }
+
+            defmt::write!(f, "{}: {}\n", name, value);
+        }
+    }
+}
+
 /// Websocket utilities
 pub mod ws {
     use crate::Method;
@@ -935,6 +1011,17 @@ pub mod ws {
         }
     }
 
+    #[cfg(feature = "defmt")]
+    impl defmt::Format for UpgradeError {
+        fn format(&self, f: defmt::Formatter<'_>) {
+            match self {
+                Self::NoVersion => defmt::write!(f, "No Sec-WebSocket-Version header"),
+                Self::NoSecKey => defmt::write!(f, "No Sec-WebSocket-Key header"),
+                Self::UnsupportedVersion => defmt::write!(f, "Unsupported Sec-WebSocket-Version"),
+            }
+        }
+    }
+
     #[cfg(feature = "std")]
     impl std::error::Error for UpgradeError {}
 

edge-mdns/src/io.rs

@@ -360,7 +360,7 @@ where
                             );
 
                             if let Err(err) = send.send(remote, data).await {
-                                warn!("Failed to reply privately to {}: {:?}", remote, err);
+                                warn!("Failed to reply privately to {}: {:?}", remote, debug2format!(err));
                             }
                         } else {
                             // Otherwise, re-broadcast the response