use std::sync::Arc;
use futures::StreamExt;
use reqwest_eventsource::{Event, RequestBuilderExt};
use tokio::sync::{Mutex, watch};
use crate::daemon::Error;
use crate::laboratories::filetree::{FileTreeEvent, FileTreeNode};
struct Shared {
state: Mutex<Vec<FileTreeNode>>,
changes: watch::Sender<u64>,
}
pub struct FileTree {
shared: Arc<Shared>,
pump: tokio::task::JoinHandle<()>,
}
impl FileTree {
pub(crate) async fn connect_daemon(
client: &crate::daemon::Client,
laboratory_id: &str,
) -> Result<FileTree, Error> {
let source = client
.open_sse(&format!("/laboratories/{laboratory_id}/filetree"))
.await?;
Ok(Self::start(source))
}
pub async fn laboratory(
base_url: &str,
path: Option<&str>,
) -> Result<FileTree, Error> {
let mut request = reqwest::Client::new()
.get(format!("{}/filetree", base_url.trim_end_matches('/')))
.header("Accept", "text/event-stream");
if let Some(path) = path {
request = request.query(&[("path", path)]);
}
let mut source = request.eventsource()?;
match source.next().await {
Some(Ok(Event::Open)) => {}
Some(Err(e)) => return Err(Error::Open(e)),
Some(Ok(Event::Message(_))) | None => return Err(Error::Closed),
}
Ok(Self::start(source))
}
fn start(source: reqwest_eventsource::EventSource) -> FileTree {
let shared = Arc::new(Shared {
state: Mutex::new(Vec::new()),
changes: watch::channel(0u64).0,
});
let pump = tokio::spawn(pump(source, shared.clone()));
FileTree { shared, pump }
}
pub async fn tree(&self) -> Vec<FileTreeNode> {
self.shared.state.lock().await.clone()
}
pub async fn subscribe(&self) {
let mut rx = self.shared.changes.subscribe();
let _ = rx.changed().await;
}
pub fn changes(&self) -> watch::Receiver<u64> {
self.shared.changes.subscribe()
}
}
impl Drop for FileTree {
fn drop(&mut self) {
self.pump.abort();
}
}
async fn pump(mut source: reqwest_eventsource::EventSource, shared: Arc<Shared>) {
while let Some(event) = source.next().await {
match event {
Ok(Event::Open) => continue,
Ok(Event::Message(message)) => {
let Ok(event) = serde_json::from_str::<FileTreeEvent>(&message.data)
else {
continue;
};
{
let mut state = shared.state.lock().await;
event.apply(&mut state);
}
shared.changes.send_modify(|version| {
*version = version.wrapping_add(1);
});
}
Err(_) => break,
}
}
}