125 lines
3.8 KiB
Rust
125 lines
3.8 KiB
Rust
use heapless::{consts, String, Vec};
|
|
use serde::Serialize;
|
|
|
|
use core::fmt::Write;
|
|
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub enum SettingsResponseCode {
|
|
NoError = 0,
|
|
NoTopic = 1,
|
|
InvalidPrefix = 2,
|
|
UnknownTopic = 3,
|
|
UpdateFailure = 4,
|
|
}
|
|
|
|
/// Represents a generic MQTT message.
|
|
pub struct MqttMessage<'a> {
|
|
pub topic: &'a str,
|
|
pub message: Vec<u8, consts::U128>,
|
|
pub properties: Vec<minimq::Property<'a>, consts::U1>,
|
|
}
|
|
|
|
/// The payload of the MQTT response message to a settings update request.
|
|
#[derive(Serialize)]
|
|
pub struct SettingsResponse {
|
|
code: u8,
|
|
msg: String<heapless::consts::U64>,
|
|
}
|
|
|
|
impl<'a> MqttMessage<'a> {
|
|
/// Construct a new MQTT message from an incoming message.
|
|
///
|
|
/// # Args
|
|
/// * `properties` - A list of properties associated with the inbound message.
|
|
/// * `default_response` - The default response topic for the message
|
|
/// * `msg` - The response associated with the message. Must fit within 128 bytes.
|
|
pub fn new<'b: 'a>(
|
|
properties: &[minimq::Property<'a>],
|
|
default_response: &'b str,
|
|
msg: &impl Serialize,
|
|
) -> Self {
|
|
// Extract the MQTT response topic.
|
|
let topic = properties
|
|
.iter()
|
|
.find_map(|prop| {
|
|
if let minimq::Property::ResponseTopic(topic) = prop {
|
|
Some(topic)
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.unwrap_or(&default_response);
|
|
|
|
// Associate any provided correlation data with the response.
|
|
let mut correlation_data: Vec<minimq::Property<'a>, consts::U1> =
|
|
Vec::new();
|
|
if let Some(data) = properties
|
|
.iter()
|
|
.find(|prop| matches!(prop, minimq::Property::CorrelationData(_)))
|
|
{
|
|
// Note(unwrap): Unwrap can not fail, as we only ever push one value.
|
|
correlation_data.push(*data).unwrap();
|
|
}
|
|
|
|
Self {
|
|
topic,
|
|
// Note(unwrap): All SettingsResponse objects are guaranteed to fit in the vector.
|
|
message: miniconf::serde_json_core::to_vec(msg).unwrap(),
|
|
properties: correlation_data,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SettingsResponse {
|
|
/// Construct a settings response upon successful settings update.
|
|
///
|
|
/// # Args
|
|
/// * `path` - The path of the setting that was updated.
|
|
pub fn update_success(path: &str) -> Self {
|
|
let mut msg: String<consts::U64> = String::new();
|
|
if write!(&mut msg, "{} updated", path).is_err() {
|
|
msg = String::from("Latest update succeeded");
|
|
}
|
|
|
|
Self {
|
|
msg,
|
|
code: SettingsResponseCode::NoError as u8,
|
|
}
|
|
}
|
|
|
|
/// Construct a response when a settings update failed.
|
|
///
|
|
/// # Args
|
|
/// * `path` - The settings path that configuration failed for.
|
|
/// * `err` - The settings update error that occurred.
|
|
pub fn update_failure(path: &str, err: miniconf::Error) -> Self {
|
|
let mut msg: String<consts::U64> = String::new();
|
|
if write!(&mut msg, "{} update failed: {:?}", path, err).is_err() {
|
|
if write!(&mut msg, "Latest update failed: {:?}", err).is_err() {
|
|
msg = String::from("Latest update failed");
|
|
}
|
|
}
|
|
|
|
Self {
|
|
msg,
|
|
code: SettingsResponseCode::UpdateFailure as u8,
|
|
}
|
|
}
|
|
|
|
/// Construct a response from a custom response code.
|
|
///
|
|
/// # Args
|
|
/// * `code` - The response code to provide.
|
|
pub fn code(code: SettingsResponseCode) -> Self {
|
|
let mut msg: String<consts::U64> = String::new();
|
|
|
|
// Note(unwrap): All code debug names shall fit in the 64 byte string.
|
|
write!(&mut msg, "{:?}", code).unwrap();
|
|
|
|
Self {
|
|
code: code as u8,
|
|
msg,
|
|
}
|
|
}
|
|
}
|