107 lines
3.0 KiB
Rust
107 lines
3.0 KiB
Rust
use crate::client::error::MessageError;
|
|
use crate::client::Client;
|
|
use crate::data_type::DataType;
|
|
use crate::data_value::DataValue;
|
|
use crate::messages::telemetry_definition::TelemetryDefinitionRequest;
|
|
use crate::messages::telemetry_entry::TelemetryEntry;
|
|
use chrono::{DateTime, Utc};
|
|
use std::sync::Arc;
|
|
use tokio::sync::{oneshot, RwLock};
|
|
use tokio_util::sync::CancellationToken;
|
|
use uuid::Uuid;
|
|
|
|
pub struct Telemetry;
|
|
|
|
impl Telemetry {
|
|
pub async fn register(
|
|
client: Arc<Client>,
|
|
name: String,
|
|
data_type: DataType,
|
|
) -> TelemetryHandle {
|
|
let cancellation_token = CancellationToken::new();
|
|
let cancel_token = cancellation_token.clone();
|
|
let stored_client = client.clone();
|
|
|
|
let response_uuid = Arc::new(RwLock::new(Uuid::nil()));
|
|
|
|
let response_uuid_inner = response_uuid.clone();
|
|
let (tx, rx) = oneshot::channel();
|
|
|
|
tokio::spawn(async move {
|
|
let mut write_lock = Some(response_uuid_inner.write().await);
|
|
let _ = tx.send(());
|
|
while !cancel_token.is_cancelled() {
|
|
if let Ok(response) = client
|
|
.send_request(TelemetryDefinitionRequest {
|
|
name: name.clone(),
|
|
data_type,
|
|
})
|
|
.await
|
|
{
|
|
let mut lock = match write_lock {
|
|
None => response_uuid_inner.write().await,
|
|
Some(lock) => lock,
|
|
};
|
|
// Update the value in the lock
|
|
*lock = response.uuid;
|
|
// Set this value so the loop works
|
|
write_lock = None;
|
|
}
|
|
|
|
client.wait_disconnected().await;
|
|
}
|
|
});
|
|
|
|
// Wait until the write lock is acquired
|
|
let _ = rx.await;
|
|
// Wait until the write lock is released for the first time
|
|
drop(response_uuid.read().await);
|
|
|
|
TelemetryHandle {
|
|
cancellation_token,
|
|
uuid: response_uuid,
|
|
client: stored_client,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct TelemetryHandle {
|
|
cancellation_token: CancellationToken,
|
|
uuid: Arc<RwLock<Uuid>>,
|
|
client: Arc<Client>,
|
|
}
|
|
|
|
impl TelemetryHandle {
|
|
pub async fn publish(
|
|
&self,
|
|
value: DataValue,
|
|
timestamp: DateTime<Utc>,
|
|
) -> Result<(), MessageError> {
|
|
let Ok(lock) = self.uuid.try_read() else {
|
|
return Ok(());
|
|
};
|
|
let uuid = *lock;
|
|
drop(lock);
|
|
|
|
self.client
|
|
.send_message_if_connected(TelemetryEntry {
|
|
uuid,
|
|
value,
|
|
timestamp,
|
|
})
|
|
.await
|
|
.or_else(|e| match e {
|
|
MessageError::TokioLockError(_) => Ok(()),
|
|
e => Err(e),
|
|
})?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Drop for TelemetryHandle {
|
|
fn drop(&mut self) {
|
|
self.cancellation_token.cancel();
|
|
}
|
|
}
|