Squash more blocking in async on mqttt

This commit is contained in:
Andrew committed 2023-04-19 11:51:50 +07:00
1 parent a46192d47c
commit 19a468ac2e
3 files changed
+409 -332

No files matched your search

+314 -269
View File
@@ -4,17 +4,16 @@ use crate::utils::AddressOrUid;
use anyhow::{anyhow, Context, Result};
use log::*;
use neolink_core::bc_protocol::{
BcCamera, Direction as BcDirection, Error as BcError, LightState, MotionStatus,
BcCamera, Direction as BcDirection, Error as BcError, LightState, MaxEncryption, MotionStatus,
};
use std::sync::Arc;
use tokio::sync::{
mpsc::{channel, error::TryRecvError, Receiver, Sender},
Mutex,
use tokio::{
sync::mpsc::{channel, Receiver, Sender},
task::JoinSet,
};
#[derive(Debug, Copy, Clone)]
pub(crate) enum Messages {
None,
Login,
MotionStop,
MotionStart,
@@ -50,103 +49,119 @@ enum ToCamera {
},
}
pub(crate) struct EventCam {
config: Arc<CameraConfig>,
app: Arc<App>,
channel_out: Arc<Mutex<Option<Receiver<Messages>>>>,
channel_in: Arc<Mutex<Option<Sender<ToCamera>>>>,
#[derive(Clone)]
pub(crate) struct EventCamSender {
channel_in: Sender<ToCamera>,
}
impl EventCam {
pub(crate) fn new(config: Arc<CameraConfig>, app: Arc<App>) -> Self {
Self {
config,
app,
channel_out: Arc::new(Mutex::new(None)),
channel_in: Arc::new(Mutex::new(None)),
}
}
pub(crate) async fn poll(&self) -> Result<Messages> {
if let Ok(ref mut channel_out) = self.channel_out.try_lock() {
if let Some(channel_out) = channel_out.as_mut() {
channel_out.recv().await.context("Camera failed to poll")
} else {
Ok(Messages::None)
}
} else {
Ok(Messages::None)
}
}
impl EventCamSender {
pub(crate) async fn send_message(&self, msg: Messages) -> Result<()> {
let mut channel_in = self.channel_in.lock().await;
if let Some(channel_in) = channel_in.as_mut() {
channel_in
.send(ToCamera::Send(msg))
.await
.context("Failed to send message from camera")
} else {
Err(anyhow!("Failed to send camera data over channel"))
}
self.channel_in
.send(ToCamera::Send(msg))
.await
.context("Failed to send message from camera")
}
pub(crate) async fn send_message_with_reply(&self, msg: Messages) -> Result<String> {
let mut channel_in = self.channel_in.lock().await;
if let Some(channel_in) = channel_in.as_mut() {
let (tx, mut rx) = channel(1);
channel_in
.send(ToCamera::SendAndReply {
message: msg,
reply: tx,
})
.await
.context("Failed to send message from camera")?;
tokio::time::timeout(std::time::Duration::from_secs(3), rx.recv())
.await
.context("Failed to recieve reply Timeout")?
.ok_or_else(|| anyhow!("Failed to recieve reply"))
} else {
Err(anyhow!("Failed to send camera data over crossbeam"))
}
let (tx, mut rx) = channel(1);
self.channel_in
.send(ToCamera::SendAndReply {
message: msg,
reply: tx,
})
.await
.context("Failed to send message from camera")?;
tokio::time::timeout(std::time::Duration::from_secs(3), rx.recv())
.await
.context("Failed to recieve reply Timeout")?
.ok_or_else(|| anyhow!("Failed to recieve reply"))
}
}
pub(crate) struct EventCam {
sender: EventCamSender,
channel_out: Receiver<Messages>,
}
pub(crate) fn abort(&self) {
self.app.abort(&self.config.name);
}
pub(crate) async fn start_listening(&self) {
let loop_config = self.config.clone();
impl EventCam {
pub(crate) async fn new(config: Arc<CameraConfig>, app: Arc<App>) -> Self {
// Channels from the camera
let (tx, rx) = channel(40);
let loop_tx = Arc::new(Mutex::new(tx));
*self.channel_out.lock().await = Some(rx);
// Channels to the camera
let (stx, srx) = channel(40);
let loop_rx = Arc::new(Mutex::new(srx));
*self.channel_in.lock().await = Some(stx);
while self.app.running(&self.config.name) {
// Ignore errors and just loop
tokio::task::yield_now().await;
let _ = Self::cam_run(
&loop_config,
loop_tx.clone(),
loop_rx.clone(),
self.app.clone(),
)
.await;
let name = config.name.clone();
let mut set = JoinSet::<Result<()>>::new();
let thread_app = app.clone();
let thread_config = config.clone();
let mut eventcam_thread = EventCamThread {
rx: srx,
tx,
app: app.clone(),
};
set.spawn(async move {
let mut wait_for = tokio::time::Duration::from_micros(125);
while thread_app.running(&name) {
// Ignore errors and just loop
tokio::task::yield_now().await;
if let Err(e) = eventcam_thread.cam_run(&thread_config).await {
warn!("Camera thread error: {:?}. Restarting...", e);
tokio::time::sleep(wait_for).await;
wait_for *= 2;
}
}
Ok(())
});
// Watch the thread and abort the app if it fails
let join_app = app;
let join_name = config.name.to_string();
tokio::task::spawn(async move {
while let Some(joined) = set.join_next().await {
tokio::task::yield_now().await;
match joined {
Err(e) => {
error!("EventCam panicked: {:?}", e);
join_app.abort(&join_name);
}
Ok(Err(e)) => {
error!("EventCam stopped with error: {:?}", e);
join_app.abort(&join_name);
}
Ok(Ok(())) => {
info!("Normal shutdown of EventCam");
}
}
info!("EventCam Loop End");
}
});
Self {
sender: EventCamSender { channel_in: stx },
channel_out: rx,
}
}
async fn cam_run(
camera_config: &CameraConfig,
tx: Arc<Mutex<Sender<Messages>>>,
rx: Arc<Mutex<Receiver<ToCamera>>>,
app: Arc<App>,
) -> Result<()> {
pub(crate) async fn poll(&mut self) -> Result<Messages> {
self.channel_out
.recv()
.await
.context("Camera failed to poll")
}
pub(crate) fn get_sender(&self) -> EventCamSender {
self.sender.clone()
}
}
struct EventCamThread {
rx: Receiver<ToCamera>,
tx: Sender<Messages>,
app: Arc<App>,
}
impl EventCamThread {
async fn cam_run(&mut self, camera_config: &CameraConfig) -> Result<()> {
let camera_addr = AddressOrUid::new(
&camera_config.camera_addr,
&camera_config.camera_uid,
@@ -169,48 +184,73 @@ impl EventCam {
})?;
info!("{}: Logging in", camera_config.name);
let max_encryption = match camera_config.max_encryption.to_lowercase().as_str() {
"none" => MaxEncryption::None,
"bcencrypt" => MaxEncryption::BcEncrypt,
"aes" => MaxEncryption::Aes,
_ => MaxEncryption::Aes,
};
camera
.login()
.login_with_maxenc(max_encryption)
.await
.context("Failed to login to the camera")?;
info!("{}: Connected and logged in", camera_config.name);
(tx.lock().await).send(Messages::Login).await?;
self.tx.send(Messages::Login).await?;
// Shararble cameras
let arc_cam = Arc::new(camera);
let mut motion_thread = MotionThread {
app: app.clone(),
tx,
app: self.app.clone(),
tx: self.tx.clone(),
camera: arc_cam.clone(),
name: camera_config.name.to_string(),
};
let thread_app = self.app.clone();
let mut message_handler = MessageHandler {
app: app.clone(),
rx,
app: self.app.clone(),
rx: &mut self.rx,
camera: arc_cam,
name: camera_config.name.to_string(),
};
let camera_name = camera_config.name.clone();
info!("{}: Listening to Camera Motion", camera_config.name);
let handle_motion = tokio::task::spawn(async move {
if let Err(e) = motion_thread.run().await {
error!("Motion thread aborted: {:?}", e);
}
app.abort(&camera_name);
});
info!("{}: Setting up camera actions", camera_config.name);
let handle_camera = tokio::task::spawn(async move {
message_handler.listen().await;
});
tokio::select! {
val = async {handle_motion.await} => {val},
val = async {handle_camera.await} => {val}
val = async {
info!("{}: Listening to Camera Motion", camera_config.name);
motion_thread.run().await
} => {
if let Err(e) = val {
error!("Motion thread aborted: {:?}", e);
Err(e)
} else {
debug!("Normal finish on motion thread");
Ok(())
}
},
val = async {
info!("{}: Setting up camera actions", camera_config.name);
message_handler.listen().await
} => {
if let Err(e) = val {
error!("Camera message handler aborted: {:?}", e);
Err(e)
} else {
debug!("Normal finish on camera message thread");
Ok(())
}
},
val = async {
while thread_app.running(&format!("app:{}", camera_config.name)) {
tokio::time::sleep(tokio::time::Duration::from_micros(500)).await
}
} => {
info!("Normal finish on cam run");
Result::Ok(())
},
}?;
self.app.abort(&camera_config.name);
Ok(())
}
@@ -218,7 +258,7 @@ impl EventCam {
struct MotionThread {
app: Arc<App>,
tx: Arc<Mutex<Sender<Messages>>>,
tx: Sender<Messages>,
camera: Arc<BcCamera>,
name: String,
}
@@ -226,17 +266,19 @@ struct MotionThread {
impl MotionThread {
async fn run(&mut self) -> Result<()> {
let mut motion_data = self.camera.listen_on_motion().await?;
let mut queued_motion = motion_data.consume_motion_events()?;
while self.app.running(&format!("app:{}", self.name)) {
for motion_status in motion_data.consume_motion_events()?.drain(..) {
tokio::task::yield_now().await;
for motion_status in queued_motion.drain(..) {
match motion_status {
MotionStatus::Start(_) => {
(self.tx.lock().await)
self.tx
.send(Messages::MotionStart)
.await
.map_err(|_| BcError::Other("Failed to send Message"))?;
}
MotionStatus::Stop(_) => {
(self.tx.lock().await)
self.tx
.send(Messages::MotionStop)
.await
.map_err(|_| BcError::Other("Failed to send Message"))?;
@@ -244,182 +286,185 @@ impl MotionThread {
_ => {}
}
}
queued_motion.push(motion_data.next_motion().await?);
}
Ok(())
}
}
struct MessageHandler {
struct MessageHandler<'a> {
app: Arc<App>,
rx: Arc<Mutex<Receiver<ToCamera>>>,
rx: &'a mut Receiver<ToCamera>,
camera: Arc<BcCamera>,
name: String,
}
impl MessageHandler {
async fn listen(&mut self) {
impl<'a> MessageHandler<'a> {
async fn listen(&mut self) -> Result<()> {
while self.app.running(&format!("app:{}", self.name)) {
// Try and lock don't worry if not
if let Ok(ref mut channel_out) = self.rx.try_lock() {
match channel_out.try_recv() {
Ok(to_camera) => {
let (replier, message) = match to_camera {
ToCamera::Send(message) => (None, message),
ToCamera::SendAndReply { message, reply } => (Some(reply), message),
};
let reply = match message {
Messages::Reboot => {
if self.camera.reboot().await.is_err() {
error!("Failed to reboot the camera");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
tokio::task::yield_now().await;
match self.rx.recv().await {
Some(to_camera) => {
let (replier, message) = match to_camera {
ToCamera::Send(message) => (None, message),
ToCamera::SendAndReply { message, reply } => (Some(reply), message),
};
let reply = match message {
Messages::Reboot => {
if self.camera.reboot().await.is_err() {
error!("Failed to reboot the camera");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
Messages::StatusLedOn => {
if self.camera.led_light_set(true).await.is_err() {
error!("Failed to turn on the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::StatusLedOff => {
if self.camera.led_light_set(false).await.is_err() {
error!("Failed to turn off the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::IRLedOn => {
if self.camera.irled_light_set(LightState::On).await.is_err() {
error!("Failed to turn on the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::IRLedOff => {
if self.camera.irled_light_set(LightState::Off).await.is_err() {
error!("Failed to turn on the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::IRLedAuto => {
if self.camera.irled_light_set(LightState::Auto).await.is_err() {
error!("Failed to turn on the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::Battery => match self.camera.battery_info().await {
Err(_) => {
error!("Failed to get battery status");
"FAIL".to_string()
}
Ok(battery_info) => {
let bytes_res = yaserde::ser::serialize_with_writer(
&battery_info,
vec![],
&Default::default(),
);
match bytes_res {
Ok(bytes) => match String::from_utf8(bytes) {
Ok(str) => str,
Err(_) => {
error!("Failed to encode battery status");
"FAIL".to_string()
}
},
Err(_) => {
error!("Failed to serialise battery status");
"FAIL".to_string()
}
}
}
},
Messages::PIRQuery => match self.camera.get_pirstate().await {
Err(_) => {
error!("Failed to get pir status");
"FAIL".to_string()
}
Ok(pir_info) => {
let bytes_res = yaserde::ser::serialize_with_writer(
&pir_info,
vec![],
&Default::default(),
);
match bytes_res {
Ok(bytes) => match String::from_utf8(bytes) {
Ok(str) => str,
Err(_) => {
error!("Failed to encode pir status");
"FAIL".to_string()
}
},
Err(_) => {
error!("Failed to serialise pir status");
"FAIL".to_string()
}
}
}
},
Messages::PIROn => {
if self.camera.pir_set(true).await.is_err() {
error!("Failed to turn on the pir");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::PIROff => {
if self.camera.pir_set(false).await.is_err() {
error!("Failed to turn on the pir");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::Ptz(direction) => {
let (bc_direction, amount) = match direction {
Direction::Up(amount) => (BcDirection::Up, amount),
Direction::Down(amount) => (BcDirection::Down, amount),
Direction::Left(amount) => (BcDirection::Left, amount),
Direction::Right(amount) => (BcDirection::Right, amount),
Direction::In(amount) => (BcDirection::In, amount),
Direction::Out(amount) => (BcDirection::Out, amount),
};
if self.camera.send_ptz(bc_direction, amount).await.is_err() {
error!("Failed to turn on the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
_ => "UNKNOWN COMMAND".to_string(),
};
if let Some(replier) = replier {
let _ = replier.send(reply).await;
}
Messages::StatusLedOn => {
if self.camera.led_light_set(true).await.is_err() {
error!("Failed to turn on the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::StatusLedOff => {
if self.camera.led_light_set(false).await.is_err() {
error!("Failed to turn off the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::IRLedOn => {
if self.camera.irled_light_set(LightState::On).await.is_err() {
error!("Failed to turn on the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::IRLedOff => {
if self.camera.irled_light_set(LightState::Off).await.is_err() {
error!("Failed to turn on the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::IRLedAuto => {
if self.camera.irled_light_set(LightState::Auto).await.is_err() {
error!("Failed to turn on the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::Battery => match self.camera.battery_info().await {
Err(_) => {
error!("Failed to get battery status");
"FAIL".to_string()
}
Ok(battery_info) => {
let bytes_res = yaserde::ser::serialize_with_writer(
&battery_info,
vec![],
&Default::default(),
);
match bytes_res {
Ok(bytes) => match String::from_utf8(bytes) {
Ok(str) => str,
Err(_) => {
error!("Failed to encode battery status");
"FAIL".to_string()
}
},
Err(_) => {
error!("Failed to serialise battery status");
"FAIL".to_string()
}
}
}
},
Messages::PIRQuery => match self.camera.get_pirstate().await {
Err(_) => {
error!("Failed to get pir status");
"FAIL".to_string()
}
Ok(pir_info) => {
let bytes_res = yaserde::ser::serialize_with_writer(
&pir_info,
vec![],
&Default::default(),
);
match bytes_res {
Ok(bytes) => match String::from_utf8(bytes) {
Ok(str) => str,
Err(_) => {
error!("Failed to encode pir status");
"FAIL".to_string()
}
},
Err(_) => {
error!("Failed to serialise pir status");
"FAIL".to_string()
}
}
}
},
Messages::PIROn => {
if self.camera.pir_set(true).await.is_err() {
error!("Failed to turn on the pir");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::PIROff => {
if self.camera.pir_set(false).await.is_err() {
error!("Failed to turn on the pir");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
Messages::Ptz(direction) => {
let (bc_direction, amount) = match direction {
Direction::Up(amount) => (BcDirection::Up, amount),
Direction::Down(amount) => (BcDirection::Down, amount),
Direction::Left(amount) => (BcDirection::Left, amount),
Direction::Right(amount) => (BcDirection::Right, amount),
Direction::In(amount) => (BcDirection::In, amount),
Direction::Out(amount) => (BcDirection::Out, amount),
};
if self.camera.send_ptz(bc_direction, amount).await.is_err() {
error!("Failed to turn on the status light");
self.abort();
"FAIL".to_string()
} else {
"OK".to_string()
}
}
_ => "UNKNOWN COMMAND".to_string(),
};
if let Some(replier) = replier {
let _ = replier.send(reply).await;
}
Err(TryRecvError::Empty) => (),
Err(TryRecvError::Disconnected) => self.abort(),
}
None => {
self.abort();
return Err(anyhow!("Message handller channel dropped"));
}
}
}
Ok(())
}
fn abort(&self) {
+90 -62
View File
@@ -115,61 +115,13 @@ async fn listen_on_camera(
arc_app: Arc<App>,
) -> Result<()> {
// Camera thread
let arc_event_cam = Arc::new(EventCam::new(cam_config.clone(), arc_app.clone()));
let mut event_cam = EventCam::new(cam_config.clone(), arc_app.clone()).await;
let mut mqtt = Mqtt::new(mqtt_config, &cam_config.name, arc_app.clone()).await;
let mut set = tokio::task::JoinSet::new();
// Start listening to camera events
let event_cam = arc_event_cam.clone();
set.spawn(async move {
event_cam.start_listening().await; // Loop forever
event_cam.abort(); // Just to ensure everything aborts
});
// Listen on camera messages and post on mqtt
let camera_name = cam_config.name.clone();
let event_cam = arc_event_cam.clone();
let app = arc_app.clone();
let mqtt_sender = mqtt.get_sender();
set.spawn(async move {
while app.running(&format!("app: {}", camera_name)) {
tokio::task::yield_now().await;
if let Ok(msg) = event_cam.poll().await {
match msg {
Messages::Login => {
if mqtt_sender
.send_message("status", "connected", true)
.await
.is_err()
{
error!("Failed to post connect over MQTT for {}", camera_name);
}
}
Messages::MotionStop => {
if mqtt_sender
.send_message("status/motion", "off", true)
.await
.is_err()
{
error!("Failed to publish motion stop for {}", camera_name);
}
}
Messages::MotionStart => {
if mqtt_sender
.send_message("status/motion", "on", true)
.await
.is_err()
{
error!("Failed to publish motion start for {}", camera_name);
}
}
_ => {}
}
}
}
});
let mqtt_sender_cam = mqtt.get_sender();
// Listen on mqtt messages and post on camera
let event_cam = arc_event_cam.clone();
let event_cam_sender = event_cam.get_sender();
let app = arc_app.clone();
let camera_name = cam_config.name.clone();
let mqtt_sender = mqtt.get_sender();
@@ -182,7 +134,11 @@ async fn listen_on_camera(
topic: "control/led",
message: "on",
} => {
if event_cam.send_message(Messages::StatusLedOn).await.is_err() {
if event_cam_sender
.send_message(Messages::StatusLedOn)
.await
.is_err()
{
error!("Failed to set camera status light on");
}
}
@@ -190,7 +146,7 @@ async fn listen_on_camera(
topic: "control/led",
message: "off",
} => {
if event_cam
if event_cam_sender
.send_message(Messages::StatusLedOff)
.await
.is_err()
@@ -202,7 +158,11 @@ async fn listen_on_camera(
topic: "control/ir",
message: "on",
} => {
if event_cam.send_message(Messages::IRLedOn).await.is_err() {
if event_cam_sender
.send_message(Messages::IRLedOn)
.await
.is_err()
{
error!("Failed to set camera status light on");
}
}
@@ -210,7 +170,11 @@ async fn listen_on_camera(
topic: "control/ir",
message: "off",
} => {
if event_cam.send_message(Messages::IRLedOff).await.is_err() {
if event_cam_sender
.send_message(Messages::IRLedOff)
.await
.is_err()
{
error!("Failed to set camera status light off");
}
}
@@ -218,7 +182,11 @@ async fn listen_on_camera(
topic: "control/ir",
message: "auto",
} => {
if event_cam.send_message(Messages::IRLedAuto).await.is_err() {
if event_cam_sender
.send_message(Messages::IRLedAuto)
.await
.is_err()
{
error!("Failed to set camera status light off");
}
}
@@ -226,7 +194,11 @@ async fn listen_on_camera(
topic: "control/reboot",
..
} => {
if event_cam.send_message(Messages::Reboot).await.is_err() {
if event_cam_sender
.send_message(Messages::Reboot)
.await
.is_err()
{
error!("Failed to set camera status light off");
}
}
@@ -251,7 +223,7 @@ async fn listen_on_camera(
continue;
}
};
if event_cam
if event_cam_sender
.send_message(Messages::Ptz(direction))
.await
.is_err()
@@ -269,7 +241,11 @@ async fn listen_on_camera(
topic: "control/pir",
message: "on",
} => {
if event_cam.send_message(Messages::PIROn).await.is_err() {
if event_cam_sender
.send_message(Messages::PIROn)
.await
.is_err()
{
error!("Failed to set pir on");
}
}
@@ -277,14 +253,21 @@ async fn listen_on_camera(
topic: "control/pir",
message: "off",
} => {
if event_cam.send_message(Messages::PIROff).await.is_err() {
if event_cam_sender
.send_message(Messages::PIROff)
.await
.is_err()
{
error!("Failed to set pir off");
}
}
MqttReplyRef {
topic: "query/battery",
..
} => match event_cam.send_message_with_reply(Messages::Battery).await {
} => match event_cam_sender
.send_message_with_reply(Messages::Battery)
.await
{
Ok(reply) => {
if mqtt_sender
.send_message("status/battery", &reply, false)
@@ -298,7 +281,10 @@ async fn listen_on_camera(
},
MqttReplyRef {
topic: "query/pir", ..
} => match event_cam.send_message_with_reply(Messages::PIRQuery).await {
} => match event_cam_sender
.send_message_with_reply(Messages::PIRQuery)
.await
{
Ok(reply) => {
if mqtt_sender
.send_message("status/pir", &reply, false)
@@ -316,6 +302,48 @@ async fn listen_on_camera(
}
});
// Listen on camera messages and post on mqtt
let camera_name = cam_config.name.clone();
let app = arc_app.clone();
set.spawn(async move {
while app.running(&format!("app: {}", camera_name)) {
tokio::task::yield_now().await;
if let Ok(msg) = event_cam.poll().await {
match msg {
Messages::Login => {
if mqtt_sender_cam
.send_message("status", "connected", true)
.await
.is_err()
{
error!("Failed to post connect over MQTT for {}", camera_name);
}
}
Messages::MotionStop => {
if mqtt_sender_cam
.send_message("status/motion", "off", true)
.await
.is_err()
{
error!("Failed to publish motion stop for {}", camera_name);
}
}
Messages::MotionStart => {
if mqtt_sender_cam
.send_message("status/motion", "on", true)
.await
.is_err()
{
error!("Failed to publish motion start for {}", camera_name);
}
}
_ => {}
}
}
}
});
while set.join_next().await.is_some() {}
Ok(())
+5 -1
View File
@@ -1,6 +1,6 @@
use super::App;
use crate::config::MqttConfig;
use anyhow::{Context, Result};
use anyhow::{anyhow, Context, Result};
use log::*;
use rumqttc::{
AsyncClient, ClientError, ConnectReturnCode, Event, EventLoop, Incoming, Key, LastWill,
@@ -121,6 +121,9 @@ impl MqttReciever {
_ => {}
}
// }
} else {
error!("Mqtt connection failure");
return Err(anyhow!("Mqtt connection failure"));
}
}
Ok(())
@@ -237,6 +240,7 @@ impl Mqtt {
}
}
}
info!("MQTT Loop End");
});
Self {