Change serde-cbor to minicbor

Cargo.toml

@@ -27,8 +27,11 @@ heapless = { version = "0.7.0", features = ["serde"] }
 mqttrust = { version = "0.6" }
 nb = "1"
 serde = { version = "1.0.126", default-features = false, features = ["derive"] }
-serde_cbor = { version = "^0.11", default-features = false, optional = true }
 serde-json-core = { version = "0.4.0" }
+
+minicbor = { version = "0.25", optional = true }
+minicbor-serde = { version = "0.3.2", optional = true }
+
 smlang = "0.5.0"
 fugit-timer = "0.1.2"
 shadow-derive = { path = "shadow_derive", version = "0.2.1" }
@@ -54,12 +57,12 @@ hex = "0.4.3"
 [features]
 default = ["ota_mqtt_data", "provision_cbor"]
 
-provision_cbor = ["serde_cbor"]
+provision_cbor = ["dep:minicbor", "dep:minicbor-serde"]
 
-ota_mqtt_data = ["serde_cbor"]
+ota_mqtt_data = ["dep:minicbor", "dep:minicbor-serde"]
 ota_http_data = []
 
-std = ["serde/std", "serde_cbor?/std"]
+std = ["serde/std", "minicbor-serde?/std"]
 
 defmt = ["dep:defmt", "mqttrust/defmt-impl", "heapless/defmt-impl"]
 

rust-toolchain.toml

@@ -1,7 +1,4 @@
 [toolchain]
-channel = "nightly-2023-06-28"
-components = [ "rust-src", "rustfmt", "llvm-tools-preview", "clippy" ]
-targets = [
-    "x86_64-unknown-linux-gnu",
-    "thumbv7em-none-eabihf"
-]
+channel = "nightly-2024-09-06"
+components = ["rust-src", "rustfmt", "llvm-tools-preview", "clippy"]
+targets = ["x86_64-unknown-linux-gnu", "thumbv7em-none-eabihf"]

src/fmt.rs

@@ -223,6 +223,7 @@ pub struct NoneError;
 pub trait Try {
     type Ok;
     type Error;
+    #[allow(dead_code)]
     fn into_result(self) -> Result<Self::Ok, Self::Error>;
 }
 

src/lib.rs

@@ -11,7 +11,5 @@ pub mod ota;
 pub mod provisioning;
 pub mod shadows;
 
-pub use serde_cbor;
-
 #[cfg(test)]
 pub mod test;

src/ota/data_interface/mqtt.rs

@@ -48,9 +48,9 @@
 }
 
 impl<'a> Topic<'a> {
     pub fn from_str(s: &'a str) -> Option<Self> {
         let tt = s.splitn(8, '/').collect::<heapless::Vec<&str, 8>>();
         Some(match (tt.get(0), tt.get(1), tt.get(2), tt.get(3)) {
             (Some(&"$aws"), Some(&"things"), _, Some(&"streams")) => {
                 // This is a stream topic! Figure out which
                 match (tt.get(4), tt.get(5), tt.get(6), tt.get(7)) {
@@ -181,7 +181,7 @@
         payload: &'c mut [u8],
     ) -> Result<FileBlock<'c>, OtaError> {
         Ok(
-            serde_cbor::de::from_mut_slice::<cbor::GetStreamResponse>(payload)
+            minicbor_serde::from_slice::<cbor::GetStreamResponse>(payload)
                 .map_err(|_| OtaError::Encoding)?
                 .into(),
         )

src/ota/encoding/cbor.rs

@@ -72,13 +72,14 @@
     pub client_token: Option<&'a str>,
 }
 
 pub fn to_slice<T>(value: &T, slice: &mut [u8]) -> Result<usize, ()>
 where
     T: serde::ser::Serialize,
 {
-    let mut serializer = serde_cbor::ser::Serializer::new(serde_cbor::ser::SliceWrite::new(slice));
+    let mut serializer =
+        minicbor_serde::Serializer::new(minicbor::encode::write::Cursor::new(slice));
     value.serialize(&mut serializer).map_err(|_| ())?;
-    Ok(serializer.into_inner().bytes_written())
+    Ok(serializer.into_encoder().writer().position())
 }
 
 impl<'a> From<GetStreamResponse<'a>> for FileBlock<'a> {
@@ -170,7 +171,7 @@
             0, 0, 0, 0, 0, 0, 255,
         ];
 
-        let response: GetStreamResponse = serde_cbor::de::from_mut_slice(payload).unwrap();
+        let response: GetStreamResponse = minicbor_serde::from_slice(payload).unwrap();
 
         assert_eq!(
             response,

src/provisioning/error.rs

@@ -27,8 +27,14 @@ impl From<serde_json_core::de::Error> for Error {
     }
 }
 
-impl From<serde_cbor::Error> for Error {
-    fn from(_e: serde_cbor::Error) -> Self {
+impl From<minicbor_serde::error::DecodeError> for Error {
+    fn from(_e: minicbor_serde::error::DecodeError) -> Self {
         Self::DeserializeCbor
     }
 }
+
+impl<E> From<minicbor_serde::error::EncodeError<E>> for Error {
+    fn from(_: minicbor_serde::error::EncodeError<E>) -> Self {
+        Self::Overflow
+    }
+}

src/provisioning/mod.rs

@@ -111,17 +111,18 @@ where
             parameters,
         };
 
-        let payload = &mut [0u8; 1024];
+        let mut payload = [0u8; 1024];
 
         let payload_len = match self.payload_format {
             #[cfg(feature = "provision_cbor")]
             PayloadFormat::Cbor => {
-                let mut serializer =
-                    serde_cbor::ser::Serializer::new(serde_cbor::ser::SliceWrite::new(payload));
+                let mut serializer = minicbor_serde::Serializer::new(
+                    minicbor::encode::write::Cursor::new(&mut payload[..]),
+                );
                 register_request.serialize(&mut serializer)?;
-                serializer.into_inner().bytes_written()
+                serializer.into_encoder().writer().position()
             }
-            PayloadFormat::Json => serde_json_core::to_slice(&register_request, payload)?,
+            PayloadFormat::Json => serde_json_core::to_slice(&register_request, &mut payload)?,
         };
 
         self.mqtt.publish(
@@ -151,7 +152,7 @@ where
                 let response = match format {
                     #[cfg(feature = "provision_cbor")]
                     PayloadFormat::Cbor => {
-                        serde_cbor::de::from_mut_slice::<CreateKeysAndCertificateResponse>(payload)?
+                        minicbor_serde::from_slice::<CreateKeysAndCertificateResponse>(payload)?
                     }
                     PayloadFormat::Json => {
                         serde_json_core::from_slice::<CreateKeysAndCertificateResponse>(payload)?.0
@@ -173,7 +174,7 @@ where
                 let response = match format {
                     #[cfg(feature = "provision_cbor")]
                     PayloadFormat::Cbor => {
-                        serde_cbor::de::from_mut_slice::<CreateCertificateFromCsrResponse>(payload)?
+                        minicbor_serde::from_slice::<CreateCertificateFromCsrResponse>(payload)?
                     }
                     PayloadFormat::Json => {
                         serde_json_core::from_slice::<CreateCertificateFromCsrResponse>(payload)?.0
@@ -195,7 +196,7 @@ where
                 let response = match format {
                     #[cfg(feature = "provision_cbor")]
                     PayloadFormat::Cbor => {
-                        serde_cbor::de::from_mut_slice::<RegisterThingResponse<'_, P>>(payload)?
+                        minicbor_serde::from_slice::<RegisterThingResponse<'_, P>>(payload)?
                     }
                     PayloadFormat::Json => {
                         serde_json_core::from_slice::<RegisterThingResponse<'_, P>>(payload)?.0
@@ -217,9 +218,7 @@ where
             ) => {
                 let response = match format {
                     #[cfg(feature = "provision_cbor")]
-                    PayloadFormat::Cbor => {
-                        serde_cbor::de::from_mut_slice::<ErrorResponse>(payload)?
-                    }
+                    PayloadFormat::Cbor => minicbor_serde::from_slice::<ErrorResponse>(payload)?,
                     PayloadFormat::Json => serde_json_core::from_slice::<ErrorResponse>(payload)?.0,
                 };
 

src/shadows/dao.rs

@@ -9,11 +9,11 @@
 
 impl<S: Serialize + DeserializeOwned> ShadowDAO<S> for () {
     fn read(&mut self) -> Result<S, Error> {
-        Err(Error::NoPersistance)
+        Err(Error::NoPersistence)
     }
 
     fn write(&mut self, _state: &S) -> Result<(), Error> {
-        Err(Error::NoPersistance)
+        Err(Error::NoPersistence)
     }
 }
 
@@ -58,10 +58,8 @@
                 }
 
                 Ok(
-                    serde_cbor::de::from_mut_slice::<S>(
-                        &mut buf[U32_SIZE..len as usize + U32_SIZE],
-                    )
-                    .map_err(|_| Error::InvalidPayload)?,
+                    minicbor_serde::from_slice::<S>(&mut buf[U32_SIZE..len as usize + U32_SIZE])
+                        .map_err(|_| Error::InvalidPayload)?,
                 )
             }
             _ => Err(Error::InvalidPayload),
@@ -73,14 +71,14 @@
 
         let buf = &mut [0u8; S::MAX_PAYLOAD_SIZE + U32_SIZE];
 
-        let mut serializer = serde_cbor::ser::Serializer::new(serde_cbor::ser::SliceWrite::new(
+        let mut serializer = minicbor_serde::Serializer::new(minicbor::encode::write::Cursor::new(
             &mut buf[U32_SIZE..],
-        ))
-        .packed_format();
+        ));
+
         state
             .serialize(&mut serializer)
             .map_err(|_| Error::InvalidPayload)?;
-        let len = serializer.into_inner().bytes_written();
+        let len = serializer.into_encoder().writer().position();
 
         if len > S::MAX_PAYLOAD_SIZE {
             return Err(Error::Overflow);

src/shadows/error.rs

@@ -11,7 +11,7 @@ use super::data_types::ErrorResponse;
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum Error {
     Overflow,
-    NoPersistance,
+    NoPersistence,
     DaoRead,
     DaoWrite,
     InvalidPayload,

src/shadows/mod.rs

@@ -94,7 +94,7 @@
 
         debug!(
             "[{:?}] Updating reported shadow value. Update_desired: {:?}",
             S::NAME.unwrap_or_else(|| CLASSIC_SHADOW),
             update_desired
         );
 
@@ -194,17 +194,17 @@
         self.handler.should_handle_topic(topic)
     }
 
-    /// Handle incomming publish messages from the cloud on any topics relevant
+    /// Handle incoming publish messages from the cloud on any topics relevant
     /// for this particular shadow.
     ///
     /// This function needs to be fed all relevant incoming MQTT payloads in
     /// order for the shadow manager to work.
     #[must_use]
     pub fn handle_message(
         &mut self,
         topic: &str,
         payload: &[u8],
     ) -> Result<(S, Option<S::PatchState>), Error> {
         let (topic, thing_name, shadow_name) =
             Topic::from_str(topic).ok_or(Error::WrongShadowName)?;
 
@@ -224,10 +224,10 @@
                 serde_json_core::from_slice::<AcceptedResponse<S::PatchState>>(payload)
                     .map_err(|_| Error::InvalidPayload)
                     .and_then(|(response, _)| {
                         if let Some(_) = response.state.delta {
                             debug!(
                                 "[{:?}] Received delta state",
                                 S::NAME.unwrap_or_else(|| CLASSIC_SHADOW)
                             );
                             self.handler.change_shadow_value(
                                 &mut state,
@@ -235,7 +235,7 @@
                                 Some(false),
                             )?;
                             Ok(response.state.delta)
                         } else if let Some(_) = response.state.reported {
                             self.handler.change_shadow_value(
                                 &mut state,
                                 response.state.reported.clone(),
@@ -253,7 +253,7 @@
                     if error.code == 404 && matches!(topic, Topic::GetRejected) {
                         debug!(
                             "[{:?}] Thing has no shadow document. Creating with defaults...",
                             S::NAME.unwrap_or_else(|| CLASSIC_SHADOW)
                         );
                         self.report_shadow()?;
                     } else {
@@ -276,16 +276,16 @@
                 // message body.
                 debug!(
                     "[{:?}] Received shadow delta event.",
                     S::NAME.unwrap_or_else(|| CLASSIC_SHADOW),
                 );
 
                 serde_json_core::from_slice::<DeltaResponse<S::PatchState>>(payload)
                     .map_err(|_| Error::InvalidPayload)
                     .and_then(|(delta, _)| {
                         if let Some(_) = delta.state {
                             debug!(
                                 "[{:?}] Delta reports new desired value. Changing local value...",
                                 S::NAME.unwrap_or_else(|| CLASSIC_SHADOW),
                             );
                         }
                         self.handler.change_shadow_value(
@@ -302,7 +302,7 @@
 
                 debug!(
                     "[{:?}] Finished updating reported shadow value.",
                     S::NAME.unwrap_or_else(|| CLASSIC_SHADOW)
                 );
 
                 None
@@ -343,10 +343,10 @@
     /// and depending on whether the state update is rejected or accepted, it
     /// will automatically update the local version after response
     ///
-    /// The returned `bool` from the update closure will determine wether the
+    /// The returned `bool` from the update closure will determine whether the
     /// update is persisted using the `DAO`, or just updated in the cloud. This
     /// can be handy for activity or status field updates that are not relevant
-    /// to store persistant on the device, but are required to be part of the
+    /// to store persistent on the device, but are required to be part of the
     /// same cloud shadow.
     pub fn update<F: FnOnce(&S, &mut S::PatchState) -> bool>(&mut self, f: F) -> Result<(), Error> {
         let mut desired = S::PatchState::default();
@@ -404,17 +404,17 @@
         self.handler.unsubscribe()
     }
 
-    /// Handle incomming publish messages from the cloud on any topics relevant
+    /// Handle incoming publish messages from the cloud on any topics relevant
     /// for this particular shadow.
     ///
     /// This function needs to be fed all relevant incoming MQTT payloads in
     /// order for the shadow manager to work.
     #[must_use]
     pub fn handle_message(
         &mut self,
         topic: &str,
         payload: &[u8],
     ) -> Result<(&S, Option<S::PatchState>), Error> {
         let (topic, thing_name, shadow_name) =
             Topic::from_str(topic).ok_or(Error::WrongShadowName)?;
 
@@ -432,17 +432,17 @@
                 serde_json_core::from_slice::<AcceptedResponse<S::PatchState>>(payload)
                     .map_err(|_| Error::InvalidPayload)
                     .and_then(|(response, _)| {
                         if let Some(_) = response.state.delta {
                             debug!(
                                 "[{:?}] Received delta state",
                                 S::NAME.unwrap_or_else(|| CLASSIC_SHADOW)
                             );
                             self.handler.change_shadow_value(
                                 &mut self.state,
                                 response.state.delta.clone(),
                                 Some(false),
                             )?;
                         } else if let Some(_) = response.state.reported {
                             self.handler.change_shadow_value(
                                 &mut self.state,
                                 response.state.reported,
@@ -458,7 +458,7 @@
                     if error.code == 404 && matches!(topic, Topic::GetRejected) {
                         debug!(
                             "[{:?}] Thing has no shadow document. Creating with defaults...",
                             S::NAME.unwrap_or_else(|| CLASSIC_SHADOW)
                         );
                         self.report_shadow()?;
                     } else {
@@ -481,16 +481,16 @@
                 // message body.
                 debug!(
                     "[{:?}] Received shadow delta event.",
                     S::NAME.unwrap_or_else(|| CLASSIC_SHADOW),
                 );
 
                 serde_json_core::from_slice::<DeltaResponse<S::PatchState>>(payload)
                     .map_err(|_| Error::InvalidPayload)
                     .and_then(|(delta, _)| {
                         if let Some(_) = delta.state {
                             debug!(
                                 "[{:?}] Delta reports new desired value. Changing local value...",
                                 S::NAME.unwrap_or_else(|| CLASSIC_SHADOW),
                             );
                         }
                         self.handler.change_shadow_value(
@@ -507,7 +507,7 @@
 
                 debug!(
                     "[{:?}] Finished updating reported shadow value.",
                     S::NAME.unwrap_or_else(|| CLASSIC_SHADOW)
                 );
 
                 None
@@ -565,7 +565,7 @@
         write!(
             f,
             "[{:?}] = {:?}",
             S::NAME.unwrap_or_else(|| CLASSIC_SHADOW),
             self.get()
         )
     }