use std::env;
use std::os::unix::fs::PermissionsExt;
use std::path::PathBuf;
use std::sync::atomic::Ordering::SeqCst;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, OnceLock};
use std::time::{Duration, UNIX_EPOCH};
use hinoirisetr::notify::InitializedNotificationSystem;
use hinoirisetr::time::Time;
use hinoirisetr::{
Config, GammaBackend, TempBackend, apply_gamma, apply_temp, compute_settings, debug, error,
info, reset_cache, trace, warn,
};
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use tokio::net::UnixListener;
use tokio::signal::unix::{SignalKind, signal};
use tokio::sync::{Notify, RwLock, RwLockReadGuard};
use tokio::time::sleep;
const SOCKET_PATH: &str = "/tmp/hinoirisetr.sock";
static CONFIG: OnceLock<Arc<RwLock<Config>>> = OnceLock::new();
static LAST_MODIFIED: AtomicU64 = AtomicU64::new(0);
enum NotifyState {
Enabled(InitializedNotificationSystem),
Disabled,
}
async fn config_reloader(notify: Arc<Notify>) {
debug!("config reloader started");
loop {
trace!("config poll tick");
let config_path = get_config_path();
if config_path.exists() {
if let Ok(current_modified) = std::fs::metadata(&config_path)
.and_then(|m| m.modified())
.map(|t| t.duration_since(UNIX_EPOCH).unwrap().as_secs())
{
let last: u64 = LAST_MODIFIED.load(Ordering::SeqCst);
if 0 != last {
if current_modified > last {
trace!("{current_modified}");
trace!("{last}");
debug!("Config file modified, reloading...");
reload_config(Arc::clone(¬ify)).await;
}
} else {
debug!("Config file detected, reloading...");
reload_config(Arc::clone(¬ify)).await;
}
}
}
sleep(Duration::from_secs(5)).await;
}
}
async fn socket_server(
disabled_temp: Arc<AtomicBool>,
disabled_gamma: Arc<AtomicBool>,
notify: Arc<Notify>,
) {
let listener = UnixListener::bind(SOCKET_PATH).expect("Failed to bind socket");
match std::fs::set_permissions(SOCKET_PATH, std::fs::Permissions::from_mode(0o600)) {
Ok(_) => {
trace!("socket file permissions set");
}
Err(e) => {
error!("Failed to set socket file permissions: {e}");
}
};
trace!("socket server bound");
let notification: NotifyState =
match hinoirisetr::notify::InitializedNotificationSystem::new("hinoirisetr") {
Ok(not) => NotifyState::Enabled(not),
Err(_) => {
info!("libnotify not found, disabling 'status_notify' command");
NotifyState::Disabled
}
};
loop {
let (mut stream, _) = listener.accept().await.unwrap();
let (reader, mut writer) = stream.split();
let mut lines = BufReader::new(reader).lines();
trace!("socket server accepted connection");
if let Ok(Some(line)) = lines.next_line().await {
match line.trim() {
"disable_temp" => {
trace!("disable_gamma dispatched");
disabled_temp.store(true, Ordering::SeqCst);
notify.notify_one();
debug!("temp dimming is disabled");
}
"disable_gamma" => {
trace!("disable_gamma dispatched");
disabled_gamma.store(true, Ordering::SeqCst);
notify.notify_one();
debug!("gamma dimming is disabled");
}
"disable" => {
trace!("disable dispatched");
disabled_temp.store(true, Ordering::SeqCst);
disabled_gamma.store(true, Ordering::SeqCst);
notify.notify_one();
debug!("dimming is disabled");
}
"enable_temp" => {
trace!("enable dispatched");
disabled_temp.store(false, Ordering::SeqCst);
notify.notify_one();
debug!("dimming is enabled");
}
"enable_gamma" => {
trace!("enable_gamma dispatched");
disabled_gamma.store(false, Ordering::SeqCst);
notify.notify_one();
debug!("gamma dimming is enabled");
}
"enable" => {
trace!("enable dispatched");
disabled_temp.store(false, Ordering::SeqCst);
disabled_gamma.store(false, Ordering::SeqCst);
notify.notify_one();
debug!("dimming is enabled");
}
"toggle_temp" => {
trace!("toggle dispatched");
let now = !disabled_temp.load(Ordering::SeqCst);
disabled_temp.store(now, Ordering::SeqCst);
notify.notify_one();
debug!(
"temp dimming is {}",
if now { "enabled" } else { "disabled" }
);
}
"toggle_gamma" => {
trace!("toggle_gamma dispatched");
let now = !disabled_gamma.load(Ordering::SeqCst);
disabled_gamma.store(now, Ordering::SeqCst);
notify.notify_one();
debug!(
"gamma dimming is {}",
if now { "enabled" } else { "disabled" }
);
}
"toggle" => {
trace!("toggle dispatched");
let now = !disabled_temp.load(Ordering::SeqCst);
disabled_temp.store(now, Ordering::SeqCst);
disabled_gamma.store(now, Ordering::SeqCst);
notify.notify_one();
debug!("dimming is {}", if now { "enabled" } else { "disabled" });
}
"status" => {
trace!("status dispatched");
let now = get_time();
let (cur_temp, cur_gamma) = compute_settings(now, &*config_guard().await);
let status = format!(
"dimming - temp: {}, gamma: {}",
if disabled_temp.load(Ordering::SeqCst) {
"disabled".to_string()
} else {
format!("{cur_temp}K")
},
if disabled_gamma.load(Ordering::SeqCst) {
"disabled".to_string()
} else {
format!("{cur_gamma}%")
}
);
if let Err(e) = writer.write(status.as_bytes()).await {
error!("Failed to write to socket: {e}");
} else {
trace!("status written to socket");
}
info!("{}", status);
}
"reload" => {
trace!("reload dispatched");
reload_config(notify.clone()).await;
}
"status_notify" => {
trace!("status_notify dispatched");
let now = get_time();
let (cur_temp, cur_gamma) = compute_settings(now, &*config_guard().await);
let status = format!(
"dimming - temp: {}, gamma: {}",
if disabled_temp.load(Ordering::SeqCst) {
"disabled".to_string()
} else {
format!("{cur_temp}K")
},
if disabled_gamma.load(Ordering::SeqCst) {
"disabled".to_string()
} else {
format!("{cur_gamma}%")
}
);
match notification {
NotifyState::Enabled(ref not) => {
trace!("notify notification enabled");
let timeout = config_guard().await.notification_timeout;
match not.show_notification(
"Sunsetting",
&status,
"notification-icon",
timeout as i32,
) {
Ok(_) => {}
Err(e) => error!("Failed to show notification: {e:?}"),
};
}
NotifyState::Disabled => {
trace!("notify notification disabled");
}
}
}
_ => error!("unknown command: {}", line.trim()),
}
}
}
}
#[tokio::main]
async fn main() {
let args: Vec<String> = std::env::args().collect();
if args.len() > 1 && (args[1] == "--version" || args[1] == "-v") {
println!("{} {}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
return;
}
match env::var("RUST_LOG") {
Ok(val) => match val.parse::<hinoirisetr::log::LogLevel>() {
Ok(level) => hinoirisetr::log::set_log_level(level),
Err(err) => error!("Failed to parse RUST_LOG: {err}"),
},
Err(_) => {
if cfg!(debug_assertions) {
hinoirisetr::log::set_log_level(hinoirisetr::log::LogLevel::Debug);
} else {
hinoirisetr::log::set_log_level(hinoirisetr::log::LogLevel::Info);
}
}
}
info!("starting the daemon");
if !is_binary_available("hyprctl") {
error!("hyprctl is not available, exiting.");
std::process::exit(1);
}
let disabled_temp = Arc::new(AtomicBool::new(false));
let disabled_gamma = Arc::new(AtomicBool::new(false));
let notify = Arc::new(Notify::new());
let config_path = get_config_path();
let cfg: Config = if config_path.exists() {
debug!("Config file found, loading...");
LAST_MODIFIED.store(
std::fs::metadata(&config_path)
.and_then(|m| m.modified())
.map(|t| t.duration_since(UNIX_EPOCH).unwrap().as_secs())
.unwrap_or(0),
SeqCst,
);
match Config::load(&config_path) {
Ok(cfg) => cfg,
Err(err) => {
error!("Failed to load config: {err:?}");
warn!("Using default config.");
Config::default()
}
}
} else {
warn!("Config file not found, using default config.");
warn!("Config path {}", get_config_path().display());
Config::default()
};
fn check_binary(binary: &str) {
if !is_binary_available(binary) {
error!("{binary} is not available, exiting.");
std::process::exit(1);
}
}
match cfg.gamma_backend {
GammaBackend::Hyprctl => check_binary("hyprctl"),
GammaBackend::Ddcutil => check_binary("ddcutil"),
GammaBackend::Xsct => check_binary("xsct"),
GammaBackend::Redshift => check_binary("redshift"),
GammaBackend::Gammastep => check_binary("gammastep"),
GammaBackend::None => {}
}
match cfg.temp_backend {
TempBackend::Hyprctl => check_binary("hyprctl"),
TempBackend::Gammastep => check_binary("gammastep"),
TempBackend::Xsct => check_binary("xsct"),
TempBackend::Redshift => check_binary("redshift"),
TempBackend::None => {}
}
if cfg.temp_backend == TempBackend::None && cfg.gamma_backend == GammaBackend::None {
error!("No backends selected, exiting.");
std::process::exit(1);
}
CONFIG.set(Arc::new(RwLock::new(cfg))).unwrap();
if std::path::Path::new(SOCKET_PATH).exists() {
match std::os::unix::net::UnixStream::connect(SOCKET_PATH) {
Ok(_) => {
error!("Another instance is running.");
std::process::exit(1);
}
Err(_) => {
warn!("Stale socket found, removing.");
let _ = std::fs::remove_file(SOCKET_PATH);
}
}
}
{
let disabled_temp = Arc::clone(&disabled_temp);
let disabled_gamma = Arc::clone(&disabled_gamma);
let notify = Arc::clone(¬ify);
tokio::spawn(async move {
socket_server(disabled_temp, disabled_gamma, notify).await;
});
}
{
let notify = Arc::clone(¬ify);
tokio::spawn(async move {
config_reloader(notify).await;
});
}
{
let notify = Arc::clone(¬ify);
tokio::spawn(async move {
loop {
sleep(Duration::from_secs(300)).await;
notify.notify_one();
}
});
}
let mut sigint = signal(SignalKind::interrupt()).unwrap();
let mut sigterm = signal(SignalKind::terminate()).unwrap();
{
let now = get_time();
let (temp, gamma) = compute_settings(now, &*config_guard().await);
apply_temp(temp, &*config_guard().await);
apply_gamma(gamma, &*config_guard().await);
trace!("initial settings applied: {temp}K, {gamma}%");
}
tokio::select! {
_ = async {
loop {
let now = get_time();
let (temp, gamma) = compute_settings(now, &*config_guard().await);
if disabled_temp.load(Ordering::SeqCst) {
apply_temp(
config_guard().await.temp_day,
&*config_guard().await,
);
} else {
apply_temp(temp, &*config_guard().await);
}
if disabled_gamma.load(Ordering::SeqCst) {
apply_gamma(
config_guard().await.gamma_day,
&*config_guard().await,
);
} else {
apply_gamma(gamma, &*config_guard().await);
}
notify.notified().await;
}} => {},
_ = sigint.recv() => {
info!("Received SIGINT, shutting down...");
},
_ = sigterm.recv() => {
info!("Received SIGTERM, shutting down...");
},
}
if std::path::Path::new(SOCKET_PATH).exists() {
match std::fs::remove_file(SOCKET_PATH) {
Ok(_) => info!("Socket file {SOCKET_PATH} removed."),
Err(e) => warn!("Failed to remove socket file {SOCKET_PATH}: {e}"),
}
}
}
async fn reload_config(notify: Arc<Notify>) {
trace!("reload_config called");
let config_handle = config_handle();
let mut config = config_handle.write().await;
let config_path = get_config_path();
match Config::load(&config_path) {
Ok(cfg) => {
debug!("Config file reloaded successfully");
fn check_binary(binary: &str) -> bool {
if !is_binary_available(binary) {
error!("{binary} is not available, exiting.");
return false;
}
true
}
let gamma_check = match cfg.gamma_backend {
GammaBackend::Hyprctl => check_binary("hyprctl"),
GammaBackend::Ddcutil => check_binary("ddcutil"),
GammaBackend::Xsct => check_binary("xsct"),
GammaBackend::Redshift => check_binary("redshift"),
GammaBackend::Gammastep => check_binary("gammastep"),
GammaBackend::None => true,
};
let temp_check = match cfg.temp_backend {
TempBackend::Hyprctl => check_binary("hyprctl"),
TempBackend::Gammastep => check_binary("gammastep"),
TempBackend::Xsct => check_binary("xsct"),
TempBackend::Redshift => check_binary("redshift"),
TempBackend::None => true,
};
if !gamma_check || !temp_check {
error!("One or more binaries are not available, retaining old config.");
return;
}
*config = cfg;
reset_cache();
let new_modified = std::fs::metadata(&config_path)
.and_then(|m| m.modified())
.map(|t| t.duration_since(UNIX_EPOCH).unwrap().as_secs())
.unwrap_or(0);
trace!("new_modified: {new_modified:?}");
LAST_MODIFIED.store(new_modified, SeqCst);
notify.notify_one();
}
Err(err) => {
error!("Failed to reload config: {err:?}");
warn!("Retaining current config");
}
}
}
fn is_binary_available(binary_name: &str) -> bool {
use std::fs;
if let Ok(paths) = env::var("PATH") {
for path in env::split_paths(&paths) {
let full_path = path.join(binary_name);
if full_path.exists()
&& fs::metadata(&full_path)
.map(|m| m.is_file())
.unwrap_or(false)
{
return true;
}
}
}
false
}
#[inline]
fn get_config_path() -> PathBuf {
if cfg!(target_os = "windows") {
let username = env::var("USERNAME").unwrap_or_else(|_| "Default".to_string());
PathBuf::from(format!(
"C:\\Users\\{username}\\AppData\\Local\\hinoirisetr.toml"
))
} else {
let xdg_config_home = env::var("XDG_CONFIG_HOME").ok();
let home = env::var("HOME").ok();
let user = env::var("USER").unwrap_or_else(|_| "default".to_string());
xdg_config_home
.map(|x| PathBuf::from(format!("{x}/hinoirisetr.toml")))
.or_else(|| home.map(|h| PathBuf::from(format!("{h}/.config/hinoirisetr.toml"))))
.unwrap_or_else(|| PathBuf::from(format!("/home/{user}/.config/hinoirisetr.toml")))
}
}
async fn config_guard() -> RwLockReadGuard<'static, Config> {
CONFIG.get().expect("config not init").read().await
}
fn config_handle() -> Arc<RwLock<Config>> {
CONFIG.get().expect("config not init").clone()
}
fn get_time() -> Time {
Time::now().expect("Failed to get local time")
}