Rename iced_sentinel to iced_beacon and refactor its API
This commit is contained in:
Héctor Ramón Jiménez
parent
aaf396256e
commit
57033dc4d0
19 changed files with 596 additions and 438 deletions
29
beacon/Cargo.toml
Normal file
29
beacon/Cargo.toml
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
[package]
|
||||
name = "iced_beacon"
|
||||
description = "A client/server protocol to monitor and supervise iced applications"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
authors.workspace = true
|
||||
license.workspace = true
|
||||
repository.workspace = true
|
||||
homepage.workspace = true
|
||||
categories.workspace = true
|
||||
keywords.workspace = true
|
||||
|
||||
[dependencies]
|
||||
iced_core.workspace = true
|
||||
iced_core.features = ["serde"]
|
||||
|
||||
bincode.workspace = true
|
||||
futures.workspace = true
|
||||
log.workspace = true
|
||||
thiserror.workspace = true
|
||||
|
||||
tokio.workspace = true
|
||||
tokio.features = ["rt", "rt-multi-thread", "net", "sync", "time", "io-util", "macros"]
|
||||
|
||||
serde.workspace = true
|
||||
serde.features = ["derive"]
|
||||
|
||||
semver.workspace = true
|
||||
semver.features = ["serde"]
|
||||
123
beacon/src/client.rs
Normal file
123
beacon/src/client.rs
Normal file
|
|
@ -0,0 +1,123 @@
|
|||
use crate::core::time::{Duration, SystemTime};
|
||||
use crate::span;
|
||||
use crate::theme;
|
||||
|
||||
use semver::Version;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use tokio::io::{self, AsyncWriteExt};
|
||||
use tokio::net;
|
||||
use tokio::sync::mpsc;
|
||||
use tokio::time;
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::thread;
|
||||
|
||||
pub const SERVER_ADDRESS: &str = "127.0.0.1:9167";
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Client {
|
||||
sender: mpsc::Sender<Message>,
|
||||
_handle: Arc<thread::JoinHandle<()>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub enum Message {
|
||||
Connected {
|
||||
at: SystemTime,
|
||||
name: String,
|
||||
version: Version,
|
||||
},
|
||||
EventLogged {
|
||||
at: SystemTime,
|
||||
event: Event,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub enum Event {
|
||||
ThemeChanged(theme::Palette),
|
||||
SpanStarted(span::Stage),
|
||||
SpanFinished(span::Stage, Duration),
|
||||
}
|
||||
|
||||
impl Client {
|
||||
pub fn log(&self, event: Event) {
|
||||
let _ = self.sender.try_send(Message::EventLogged {
|
||||
at: SystemTime::now(),
|
||||
event,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn connect(name: String) -> Client {
|
||||
let (sender, receiver) = mpsc::channel(100);
|
||||
|
||||
let handle = std::thread::spawn(move || run(name, receiver));
|
||||
|
||||
Client {
|
||||
sender,
|
||||
_handle: Arc::new(handle),
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn run(name: String, mut receiver: mpsc::Receiver<Message>) {
|
||||
let version = semver::Version::parse(env!("CARGO_PKG_VERSION"))
|
||||
.expect("Parse package version");
|
||||
|
||||
loop {
|
||||
match _connect().await {
|
||||
Ok(mut stream) => {
|
||||
let _ = send(
|
||||
&mut stream,
|
||||
Message::Connected {
|
||||
at: SystemTime::now(),
|
||||
name: name.clone(),
|
||||
version: version.clone(),
|
||||
},
|
||||
)
|
||||
.await;
|
||||
|
||||
while let Some(output) = receiver.recv().await {
|
||||
match send(&mut stream, output).await {
|
||||
Ok(()) => {}
|
||||
Err(error) => {
|
||||
log::warn!(
|
||||
"Error sending message to server: {error}"
|
||||
);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(_) => {
|
||||
time::sleep(time::Duration::from_secs(2)).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn _connect() -> Result<net::TcpStream, io::Error> {
|
||||
log::debug!("Attempting to connect to server...");
|
||||
let stream = net::TcpStream::connect(SERVER_ADDRESS).await?;
|
||||
|
||||
stream.set_nodelay(true)?;
|
||||
stream.writable().await?;
|
||||
|
||||
Ok(stream)
|
||||
}
|
||||
|
||||
async fn send(
|
||||
stream: &mut net::TcpStream,
|
||||
message: Message,
|
||||
) -> Result<(), io::Error> {
|
||||
let bytes = bincode::serialize(&message).expect("Encode input message");
|
||||
let size = bytes.len() as u64;
|
||||
|
||||
stream.write_all(&size.to_be_bytes()).await?;
|
||||
stream.write_all(&bytes).await?;
|
||||
stream.flush().await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
184
beacon/src/lib.rs
Normal file
184
beacon/src/lib.rs
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
pub use iced_core as core;
|
||||
pub use semver::Version;
|
||||
|
||||
pub mod client;
|
||||
pub mod span;
|
||||
|
||||
mod stream;
|
||||
|
||||
pub use client::Client;
|
||||
pub use span::Span;
|
||||
|
||||
use crate::core::theme;
|
||||
use crate::core::time::{Duration, SystemTime};
|
||||
|
||||
use futures::{SinkExt, Stream};
|
||||
use tokio::io::{self, AsyncReadExt};
|
||||
use tokio::net;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum Event {
|
||||
Connected {
|
||||
at: SystemTime,
|
||||
name: String,
|
||||
version: Version,
|
||||
},
|
||||
Disconnected {
|
||||
at: SystemTime,
|
||||
},
|
||||
ThemeChanged {
|
||||
at: SystemTime,
|
||||
palette: theme::Palette,
|
||||
},
|
||||
SpanFinished {
|
||||
at: SystemTime,
|
||||
duration: Duration,
|
||||
span: Span,
|
||||
},
|
||||
}
|
||||
|
||||
impl Event {
|
||||
pub fn at(&self) -> SystemTime {
|
||||
match self {
|
||||
Self::Connected { at, .. }
|
||||
| Self::Disconnected { at, .. }
|
||||
| Self::ThemeChanged { at, .. }
|
||||
| Self::SpanFinished { at, .. } => *at,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run() -> impl Stream<Item = Event> {
|
||||
stream::channel(|mut output| async move {
|
||||
let mut buffer = Vec::new();
|
||||
|
||||
loop {
|
||||
let Ok(mut stream) = connect().await else {
|
||||
delay().await;
|
||||
continue;
|
||||
};
|
||||
|
||||
loop {
|
||||
match receive(&mut stream, &mut buffer).await {
|
||||
Ok(message) => {
|
||||
match message {
|
||||
client::Message::Connected {
|
||||
at,
|
||||
name,
|
||||
version,
|
||||
} => {
|
||||
let _ = output
|
||||
.send(Event::Connected {
|
||||
at,
|
||||
name,
|
||||
version,
|
||||
})
|
||||
.await;
|
||||
}
|
||||
client::Message::EventLogged { at, event } => {
|
||||
match event {
|
||||
client::Event::ThemeChanged(palette) => {
|
||||
let _ = output
|
||||
.send(Event::ThemeChanged {
|
||||
at,
|
||||
palette,
|
||||
})
|
||||
.await;
|
||||
}
|
||||
client::Event::SpanStarted(_) => {}
|
||||
client::Event::SpanFinished(
|
||||
stage,
|
||||
duration,
|
||||
) => {
|
||||
let span = match stage {
|
||||
span::Stage::Boot => Span::Boot,
|
||||
span::Stage::Update => Span::Update,
|
||||
span::Stage::View(window) => {
|
||||
Span::View { window }
|
||||
}
|
||||
span::Stage::Layout(window) => {
|
||||
Span::Layout { window }
|
||||
}
|
||||
span::Stage::Interact(window) => {
|
||||
Span::Interact { window }
|
||||
}
|
||||
span::Stage::Draw(window) => {
|
||||
Span::Draw { window }
|
||||
}
|
||||
span::Stage::Present(window) => {
|
||||
Span::Present { window }
|
||||
}
|
||||
span::Stage::Custom(
|
||||
window,
|
||||
name,
|
||||
) => Span::Custom { window, name },
|
||||
};
|
||||
|
||||
let _ = output
|
||||
.send(Event::SpanFinished {
|
||||
at,
|
||||
duration,
|
||||
span,
|
||||
})
|
||||
.await;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
Err(Error::IOFailed(_)) => {
|
||||
let _ = output
|
||||
.send(Event::Disconnected {
|
||||
at: SystemTime::now(),
|
||||
})
|
||||
.await;
|
||||
|
||||
delay().await;
|
||||
break;
|
||||
}
|
||||
Err(Error::DecodingFailed(error)) => {
|
||||
log::warn!("Error decoding beacon output: {error}")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
async fn connect() -> Result<net::TcpStream, io::Error> {
|
||||
let listener = net::TcpListener::bind(client::SERVER_ADDRESS).await?;
|
||||
|
||||
let (stream, _) = listener.accept().await?;
|
||||
|
||||
stream.set_nodelay(true)?;
|
||||
stream.readable().await?;
|
||||
|
||||
Ok(stream)
|
||||
}
|
||||
|
||||
async fn receive(
|
||||
stream: &mut net::TcpStream,
|
||||
buffer: &mut Vec<u8>,
|
||||
) -> Result<client::Message, Error> {
|
||||
let size = stream.read_u64().await? as usize;
|
||||
|
||||
if buffer.len() < size {
|
||||
buffer.resize(size, 0);
|
||||
}
|
||||
|
||||
let _n = stream.read_exact(&mut buffer[..size]).await?;
|
||||
|
||||
Ok(bincode::deserialize(buffer)?)
|
||||
}
|
||||
|
||||
async fn delay() {
|
||||
tokio::time::sleep(Duration::from_secs(2)).await;
|
||||
}
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
enum Error {
|
||||
#[error("input/output operation failed: {0}")]
|
||||
IOFailed(#[from] io::Error),
|
||||
#[error("decoding failed: {0}")]
|
||||
DecodingFailed(#[from] Box<bincode::ErrorKind>),
|
||||
}
|
||||
61
beacon/src/span.rs
Normal file
61
beacon/src/span.rs
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
use crate::core::window;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
pub enum Span {
|
||||
Boot,
|
||||
Update,
|
||||
View { window: window::Id },
|
||||
Layout { window: window::Id },
|
||||
Interact { window: window::Id },
|
||||
Draw { window: window::Id },
|
||||
Present { window: window::Id },
|
||||
Custom { window: window::Id, name: String },
|
||||
}
|
||||
|
||||
impl Span {
|
||||
pub fn stage(&self) -> Stage {
|
||||
match self {
|
||||
Span::Boot => Stage::Boot,
|
||||
Span::Update => Stage::Update,
|
||||
Span::View { window } => Stage::View(*window),
|
||||
Span::Layout { window } => Stage::Layout(*window),
|
||||
Span::Interact { window } => Stage::Interact(*window),
|
||||
Span::Draw { window } => Stage::Draw(*window),
|
||||
Span::Present { window } => Stage::Present(*window),
|
||||
Span::Custom { window, name } => {
|
||||
Stage::Custom(*window, name.clone())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(
|
||||
Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
|
||||
)]
|
||||
pub enum Stage {
|
||||
Boot,
|
||||
Update,
|
||||
View(window::Id),
|
||||
Layout(window::Id),
|
||||
Interact(window::Id),
|
||||
Draw(window::Id),
|
||||
Present(window::Id),
|
||||
Custom(window::Id, String),
|
||||
}
|
||||
|
||||
impl std::fmt::Display for Stage {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(match self {
|
||||
Stage::Boot => "Boot",
|
||||
Stage::Update => "Update",
|
||||
Stage::View(_) => "View",
|
||||
Stage::Layout(_) => "Layout",
|
||||
Stage::Interact(_) => "Interact",
|
||||
Stage::Draw(_) => "Draw",
|
||||
Stage::Present(_) => "Present",
|
||||
Stage::Custom(_, name) => name,
|
||||
})
|
||||
}
|
||||
}
|
||||
15
beacon/src/stream.rs
Normal file
15
beacon/src/stream.rs
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
use futures::channel::mpsc;
|
||||
use futures::stream::{self, Stream, StreamExt};
|
||||
use futures::Future;
|
||||
|
||||
pub fn channel<T, F>(f: impl Fn(mpsc::Sender<T>) -> F) -> impl Stream<Item = T>
|
||||
where
|
||||
F: Future<Output = ()>,
|
||||
{
|
||||
let (sender, receiver) = mpsc::channel(1);
|
||||
|
||||
stream::select(
|
||||
receiver,
|
||||
stream::once(f(sender)).filter_map(|_| async { None }),
|
||||
)
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue