152 lines
4.9 KiB
Rust
152 lines
4.9 KiB
Rust
use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
|
|
use crate::script::exec_command;
|
|
use color_eyre::{Help, Report, Result};
|
|
use gtk::prelude::*;
|
|
use gtk::Label;
|
|
use serde::Deserialize;
|
|
use std::process::Stdio;
|
|
use tokio::io::{AsyncBufReadExt, BufReader};
|
|
use tokio::process::Command;
|
|
use tokio::sync::mpsc::{Receiver, Sender};
|
|
use tokio::time::sleep;
|
|
use tokio::{select, spawn};
|
|
use tracing::error;
|
|
|
|
#[derive(Debug, Deserialize, Clone, Copy)]
|
|
#[serde(rename_all = "kebab-case")]
|
|
enum Mode {
|
|
Poll,
|
|
Watch,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, Clone)]
|
|
pub struct ScriptModule {
|
|
/// Path to script to execute.
|
|
path: String,
|
|
/// Script execution mode
|
|
#[serde(default = "default_mode")]
|
|
mode: Mode,
|
|
/// Time in milliseconds between executions.
|
|
#[serde(default = "default_interval")]
|
|
interval: u64,
|
|
}
|
|
|
|
/// `Mode::Poll`
|
|
const fn default_mode() -> Mode {
|
|
Mode::Poll
|
|
}
|
|
|
|
/// 5000ms
|
|
const fn default_interval() -> u64 {
|
|
5000
|
|
}
|
|
|
|
impl Module<Label> for ScriptModule {
|
|
type SendMessage = String;
|
|
type ReceiveMessage = ();
|
|
|
|
fn spawn_controller(
|
|
&self,
|
|
_info: &ModuleInfo,
|
|
tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
|
|
_rx: Receiver<Self::ReceiveMessage>,
|
|
) -> Result<()> {
|
|
let interval = self.interval;
|
|
let path = self.path.clone();
|
|
|
|
match self.mode {
|
|
Mode::Poll => spawn(async move {
|
|
loop {
|
|
match exec_command(&path) {
|
|
Ok(stdout) => tx
|
|
.send(ModuleUpdateEvent::Update(stdout))
|
|
.await
|
|
.expect("Failed to send stdout"),
|
|
Err(err) => error!("{:?}", err),
|
|
}
|
|
|
|
sleep(tokio::time::Duration::from_millis(interval)).await;
|
|
}
|
|
}),
|
|
Mode::Watch => spawn(async move {
|
|
loop {
|
|
let mut handle = Command::new("sh")
|
|
.args(["-c", &path])
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.stdin(Stdio::null())
|
|
.spawn()
|
|
.expect("Failed to spawn process");
|
|
|
|
let mut stdout_lines = BufReader::new(
|
|
handle
|
|
.stdout
|
|
.take()
|
|
.expect("Failed to take script handle stdout"),
|
|
)
|
|
.lines();
|
|
|
|
let mut stderr_lines = BufReader::new(
|
|
handle
|
|
.stderr
|
|
.take()
|
|
.expect("Failed to take script handle stderr"),
|
|
)
|
|
.lines();
|
|
|
|
loop {
|
|
select! {
|
|
_ = handle.wait() => break,
|
|
Ok(Some(line)) = stdout_lines.next_line() => {
|
|
tx.send(ModuleUpdateEvent::Update(line.to_string()))
|
|
.await
|
|
.expect("Failed to send stdout");
|
|
}
|
|
Ok(Some(line)) = stderr_lines.next_line() => {
|
|
error!("{:?}", Report::msg(line)
|
|
.wrap_err("Watched script error:")
|
|
.suggestion("Check the path to your script")
|
|
.suggestion("Check the script for errors")
|
|
.suggestion("If you expect the script to write to stderr, consider redirecting its output to /dev/null to suppress these messages")
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
while let Ok(Some(line)) = stdout_lines.next_line().await {
|
|
tx.send(ModuleUpdateEvent::Update(line.to_string()))
|
|
.await
|
|
.expect("Failed to send stdout");
|
|
}
|
|
|
|
sleep(tokio::time::Duration::from_millis(interval)).await;
|
|
}
|
|
}),
|
|
};
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn into_widget(
|
|
self,
|
|
context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
|
|
info: &ModuleInfo,
|
|
) -> Result<ModuleWidget<Label>> {
|
|
let label = Label::builder().use_markup(true).build();
|
|
label.set_angle(info.bar_position.get_angle());
|
|
|
|
{
|
|
let label = label.clone();
|
|
context.widget_rx.attach(None, move |s| {
|
|
label.set_markup(s.as_str());
|
|
Continue(true)
|
|
});
|
|
}
|
|
|
|
Ok(ModuleWidget {
|
|
widget: label,
|
|
popup: None,
|
|
})
|
|
}
|
|
}
|