98 lines
3.5 KiB
Rust
98 lines
3.5 KiB
Rust
use crate::daemon::{
|
|
Daemon,
|
|
DaemonResult,
|
|
|
|
events::{Event, Reply},
|
|
target,
|
|
};
|
|
|
|
use kordophone::APIInterface;
|
|
use kordophone::api::event_socket::EventSocket;
|
|
use kordophone::model::event::Event as UpdateEvent;
|
|
|
|
use kordophone_db::database::Database;
|
|
|
|
use tokio::sync::mpsc::Sender;
|
|
use std::sync::Arc;
|
|
use tokio::sync::Mutex;
|
|
|
|
pub struct UpdateMonitor {
|
|
database: Arc<Mutex<Database>>,
|
|
event_sender: Sender<Event>,
|
|
}
|
|
|
|
impl UpdateMonitor {
|
|
pub fn new(database: Arc<Mutex<Database>>, event_sender: Sender<Event>) -> Self {
|
|
Self { database, event_sender }
|
|
}
|
|
|
|
pub async fn send_event<T>(
|
|
&self,
|
|
make_event: impl FnOnce(Reply<T>) -> Event,
|
|
) -> DaemonResult<T> {
|
|
let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
|
|
self.event_sender.send(make_event(reply_tx))
|
|
.await
|
|
.map_err(|_| "Failed to send event")?;
|
|
|
|
reply_rx.await.map_err(|_| "Failed to receive reply".into())
|
|
}
|
|
|
|
async fn handle_update(&mut self, update: UpdateEvent) {
|
|
match update {
|
|
UpdateEvent::ConversationChanged(conversation) => {
|
|
log::info!(target: target::UPDATES, "Conversation changed: {:?}", conversation);
|
|
log::info!(target: target::UPDATES, "Triggering conversation list sync");
|
|
self.send_event(Event::SyncConversationList).await
|
|
.unwrap_or_else(|e| {
|
|
log::error!("Failed to send daemon event: {}", e);
|
|
});
|
|
}
|
|
|
|
UpdateEvent::MessageReceived(conversation, message) => {
|
|
log::info!(target: target::UPDATES, "Message received: msgid:{:?}, convid:{:?}", message.guid, conversation.guid);
|
|
log::info!(target: target::UPDATES, "Triggering message sync for conversation id: {}", conversation.guid);
|
|
self.send_event(|r| Event::SyncConversation(conversation.guid, r)).await
|
|
.unwrap_or_else(|e| {
|
|
log::error!("Failed to send daemon event: {}", e);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn run(&mut self) {
|
|
use futures_util::stream::StreamExt;
|
|
|
|
log::info!(target: target::UPDATES, "Starting update monitor");
|
|
|
|
loop {
|
|
log::debug!(target: target::UPDATES, "Creating client");
|
|
let mut client = match Daemon::get_client_impl(&mut self.database).await {
|
|
Ok(client) => client,
|
|
Err(e) => {
|
|
log::error!("Failed to get client: {}", e);
|
|
log::warn!("Retrying in 5 seconds...");
|
|
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
|
|
continue;
|
|
}
|
|
};
|
|
|
|
log::debug!(target: target::UPDATES, "Opening event socket");
|
|
let socket = match client.open_event_socket().await {
|
|
Ok(events) => events,
|
|
Err(e) => {
|
|
log::warn!("Failed to open event socket: {}", e);
|
|
log::warn!("Retrying in 5 seconds...");
|
|
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
|
|
continue;
|
|
}
|
|
};
|
|
|
|
log::debug!(target: target::UPDATES, "Starting event stream");
|
|
let mut event_stream = socket.events().await;
|
|
while let Some(Ok(event)) = event_stream.next().await {
|
|
self.handle_update(event).await;
|
|
}
|
|
}
|
|
}
|
|
} |