343 lines
10 KiB
Bash
343 lines
10 KiB
Bash
# eww-bar — lifecycle manager for the eww daemon and the bar window.
|
|
#
|
|
# The daemon is owned by the user unit eww.service. Two eww facts shape this
|
|
# script:
|
|
#
|
|
# * A client waits only 100 ms for the daemon's reply. Any slower command
|
|
# (opening the popup, reload) fails on the client side, and a plain
|
|
# `eww open` then forks a SECOND daemon that takes over the socket path and
|
|
# orphans the first one's surfaces ("two bars", "a popup I can't close").
|
|
# Every client call here passes --no-daemonize, which turns that into a
|
|
# harmless error; outcomes are verified with `active-windows`, never with
|
|
# the exit status.
|
|
# * `eww ping` is answered by the IPC thread; `eww active-windows` by the GTK
|
|
# main loop. Only the latter proves the UI is alive.
|
|
#
|
|
# SCREEN is a GDK monitor index (0), a connector name (DP-1) or
|
|
# desc:<prefix of the description shown by `hyprctl monitors`>. Descriptions
|
|
# survive re-plugging and profile changes; indices do not.
|
|
|
|
usage() {
|
|
cat <<'USAGE'
|
|
usage: eww-bar COMMAND [ARGS]
|
|
|
|
ensure make sure a healthy, service-owned daemon is running
|
|
open [SCREEN] open the bar (no-op if already open there), remember SCREEN
|
|
place [SCREEN] force re-open of the bar on SCREEN (used by kanshi)
|
|
close close the bar and the popups
|
|
reload reload the eww config and re-place the bar
|
|
restart restart eww.service (the bar comes back with it)
|
|
reset kill every eww process, wipe the sockets, start fresh
|
|
check health check run by eww-watchdog.timer
|
|
clean ExecStartPre: kill stray daemons, wipe stale sockets
|
|
focused print the name of the focused Hyprland monitor
|
|
status show unit state, socket owner, open windows and screen
|
|
USAGE
|
|
}
|
|
|
|
uid=$(id -u)
|
|
runtime_dir=${XDG_RUNTIME_DIR:-/run/user/$uid}
|
|
state_dir=$runtime_dir/eww-bar
|
|
lock_file=$state_dir/lock
|
|
screen_file=$state_dir/screen # requested screen spec, re-resolved on restart
|
|
current_file=$state_dir/current # resolved screen the bar is currently on
|
|
fail_file=$state_dir/strikes
|
|
unit=eww.service
|
|
default_screen=0
|
|
max_strikes=2
|
|
|
|
mkdir -p "$state_dir"
|
|
|
|
log() { printf 'eww-bar: %s\n' "$*" >&2; }
|
|
|
|
# ---------------------------------------------------------------- client ---
|
|
|
|
# fd 9 (the lock) is closed for every client call so nothing can inherit it.
|
|
ewwc() { timeout 5 eww --no-daemonize "$@" 9>&-; }
|
|
|
|
ping_daemon() { ewwc ping >/dev/null 2>&1; }
|
|
list_windows() { ewwc active-windows 2>/dev/null || true; }
|
|
bar_open() { list_windows | grep -qx 'bar: bar'; }
|
|
|
|
# wait_for_window NAME [SECONDS]
|
|
wait_for_window() {
|
|
local i n=$((${2:-5} * 5))
|
|
for ((i = 0; i < n; i++)); do
|
|
list_windows | grep -qx "$1: $1" && return 0
|
|
sleep 0.2
|
|
done
|
|
return 1
|
|
}
|
|
|
|
# ---------------------------------------------------------------- daemon ---
|
|
|
|
# nixpkgs wraps eww (wrapGAppsHook), so the running process is `.eww-wrapped`;
|
|
# `pkill -x eww` never matched it. Exact match, this user only.
|
|
kill_stray_daemons() {
|
|
pkill -TERM -x -u "$uid" '(\.eww-wrapped|eww)' 2>/dev/null || true
|
|
sleep 0.3
|
|
pkill -KILL -x -u "$uid" '(\.eww-wrapped|eww)' 2>/dev/null || true
|
|
rm -f "$runtime_dir"/eww-server_*
|
|
}
|
|
|
|
unit_state() { systemctl --user show -p ActiveState --value "$unit" 2>/dev/null || echo unknown; }
|
|
unit_running() {
|
|
case $(unit_state) in
|
|
active | activating | reloading) return 0 ;;
|
|
*) return 1 ;;
|
|
esac
|
|
}
|
|
main_pid() { systemctl --user show -p MainPID --value "$unit" 2>/dev/null || echo 0; }
|
|
|
|
# pids listening on an eww socket path. After a rival rebinds the path, ss
|
|
# lists BOTH sockets under the same name (the old one is merely unlinked), so
|
|
# every pid matters, not just the first.
|
|
socket_owners() {
|
|
ss -xlp 2>/dev/null | grep -F "$runtime_dir/eww-server_" \
|
|
| sed -n 's/.*pid=\([0-9]*\).*/\1/p' | sort -u | tr '\n' ' '
|
|
}
|
|
|
|
# The socket file is gone while the daemon lives on: a rival that crashed at
|
|
# startup unlinked it, and no client can reach the daemon any more.
|
|
socket_missing() { ! ls "$runtime_dir"/eww-server_* >/dev/null 2>&1; }
|
|
daemon_age() { ps -o etimes= -p "$(main_pid)" 2>/dev/null | tr -d " " || echo 0; }
|
|
|
|
# pids of daemons other than the service's main process listening on the socket
|
|
rival_pids() {
|
|
local main pid
|
|
main=$(main_pid)
|
|
for pid in $(socket_owners); do
|
|
[[ $pid != "$main" ]] && printf '%s ' "$pid"
|
|
done
|
|
return 0
|
|
}
|
|
rival_daemon() { [[ -n $(rival_pids) ]]; }
|
|
|
|
healthy() { unit_running && ping_daemon && ! rival_daemon; }
|
|
|
|
wait_for_daemon() {
|
|
local i
|
|
for ((i = 0; i < 100; i++)); do
|
|
ping_daemon && return 0
|
|
sleep 0.1
|
|
done
|
|
return 1
|
|
}
|
|
|
|
start_unit() {
|
|
systemctl --user reset-failed "$unit" >/dev/null 2>&1 || true
|
|
systemctl --user start "$unit"
|
|
}
|
|
|
|
restart_unit() {
|
|
log "restarting $unit"
|
|
systemctl --user reset-failed "$unit" >/dev/null 2>&1 || true
|
|
systemctl --user restart "$unit"
|
|
}
|
|
|
|
ensure() {
|
|
healthy && return 0
|
|
(
|
|
flock -x 9
|
|
healthy && exit 0
|
|
if rival_daemon; then
|
|
log "a second eww daemon (pid $(rival_pids)) owns the socket"
|
|
elif unit_running && wait_for_daemon && ! rival_daemon; then
|
|
# The unit was (re)starting — possibly running us from ExecStartPost.
|
|
exit 0
|
|
fi
|
|
log "daemon unhealthy, restarting $unit"
|
|
systemctl --user stop "$unit" >/dev/null 2>&1 || true
|
|
kill_stray_daemons
|
|
start_unit
|
|
wait_for_daemon
|
|
) 9>"$lock_file"
|
|
}
|
|
|
|
# --------------------------------------------------------------- screens ---
|
|
|
|
focused_monitor() {
|
|
hyprctl -j monitors 2>/dev/null | jq -r 'first(.[] | select(.focused) | .name) // empty'
|
|
}
|
|
|
|
# desc:<prefix> → connector name via hyprctl; anything else is passed to eww.
|
|
resolve_screen() {
|
|
local spec=$1 name
|
|
case $spec in
|
|
desc:*)
|
|
name=$(hyprctl -j monitors 2>/dev/null \
|
|
| jq -r --arg p "${spec#desc:}" '[.[] | select(.description | startswith($p))][0].name // empty')
|
|
if [[ -n $name ]]; then
|
|
printf '%s\n' "$name"
|
|
else
|
|
log "no monitor matches '$spec', using screen $default_screen"
|
|
printf '%s\n' "$default_screen"
|
|
fi
|
|
;;
|
|
'') printf '%s\n' "$default_screen" ;;
|
|
*) printf '%s\n' "$spec" ;;
|
|
esac
|
|
}
|
|
|
|
saved_screen() { cat "$screen_file" 2>/dev/null || true; }
|
|
current_screen() { cat "$current_file" 2>/dev/null || true; }
|
|
|
|
# ------------------------------------------------------------------- bar ---
|
|
|
|
close_popups() {
|
|
local w
|
|
for w in popup powermenu; do
|
|
list_windows | grep -qx "$w: $w" && { ewwc close "$w" >/dev/null 2>&1 || true; }
|
|
done
|
|
ewwc update active-panel= >/dev/null 2>&1 || true
|
|
}
|
|
|
|
# open_bar [--force] [SPEC]
|
|
open_bar() {
|
|
local force=0 spec screen
|
|
if [[ ${1:-} == --force ]]; then force=1; shift; fi
|
|
spec=${1:-$(saved_screen)}
|
|
spec=${spec:-$default_screen}
|
|
ensure || { log "no daemon, cannot open the bar"; return 1; }
|
|
screen=$(resolve_screen "$spec")
|
|
(
|
|
flock -x 9
|
|
if ((force == 0)) && [[ $(current_screen) == "$screen" ]] && bar_open; then
|
|
exit 0
|
|
fi
|
|
# Popups may sit on an output that just vanished; `eww open` itself
|
|
# replaces an already-open bar. The exit status is meaningless (100 ms
|
|
# client deadline), so the result is verified instead.
|
|
close_popups
|
|
ewwc open bar --screen "$screen" >/dev/null 2>&1 || true
|
|
if ! wait_for_window bar 5; then
|
|
if [[ $screen != "$default_screen" ]]; then
|
|
log "cannot open the bar on '$screen', using screen $default_screen"
|
|
screen=$default_screen
|
|
ewwc open bar --screen "$screen" >/dev/null 2>&1 || true
|
|
fi
|
|
if ! wait_for_window bar 5; then
|
|
log "the bar does not come up, restarting $unit"
|
|
restart_unit
|
|
exit 1
|
|
fi
|
|
fi
|
|
printf '%s\n' "$spec" >"$screen_file"
|
|
printf '%s\n' "$screen" >"$current_file"
|
|
log "bar opened on screen $screen"
|
|
) 9>"$lock_file"
|
|
}
|
|
|
|
close_bar() {
|
|
close_popups
|
|
ewwc close bar >/dev/null 2>&1 || true
|
|
rm -f "$current_file"
|
|
}
|
|
|
|
reload() {
|
|
ensure || return 1
|
|
# Slow: the client always hits its deadline, so ignore the status and
|
|
# verify that the daemon is still with us afterwards.
|
|
ewwc reload >/dev/null 2>&1 || true
|
|
sleep 1
|
|
if ! wait_for_daemon; then
|
|
log "daemon lost during reload, restarting $unit"
|
|
restart_unit
|
|
return 0
|
|
fi
|
|
open_bar --force
|
|
}
|
|
|
|
reset() {
|
|
log "full reset"
|
|
systemctl --user stop "$unit" >/dev/null 2>&1 || true
|
|
kill_stray_daemons
|
|
rm -f "$current_file" "$fail_file"
|
|
start_unit # ExecStartPost re-opens the bar
|
|
}
|
|
|
|
# ExecStartPre
|
|
clean() {
|
|
kill_stray_daemons
|
|
rm -f "$current_file" "$fail_file"
|
|
}
|
|
|
|
# -------------------------------------------------------------- watchdog ---
|
|
|
|
# One bad check is tolerated (a busy daemon can miss eww's 100 ms IPC reply
|
|
# deadline); the second consecutive one restarts the unit.
|
|
strike() {
|
|
local n
|
|
n=$(($(cat "$fail_file" 2>/dev/null || echo 0) + 1))
|
|
if ((n >= max_strikes)); then
|
|
log "$1 ($n/$max_strikes) — restarting $unit"
|
|
rm -f "$fail_file"
|
|
restart_unit
|
|
else
|
|
log "$1 ($n/$max_strikes)"
|
|
printf '%s\n' "$n" >"$fail_file"
|
|
fi
|
|
}
|
|
|
|
check() {
|
|
systemctl --user is-active --quiet graphical-session.target || return 0
|
|
if ! unit_running; then
|
|
log "$unit is not running, starting it"
|
|
start_unit || true
|
|
return 0
|
|
fi
|
|
[[ $(unit_state) == active ]] || return 0 # still starting; ExecStartPost handles it
|
|
if rival_daemon; then
|
|
log "a second eww daemon (pid $(rival_pids)) owns the socket, restarting $unit"
|
|
restart_unit
|
|
return 0
|
|
fi
|
|
if socket_missing && (($(daemon_age) > 15)); then
|
|
log "socket file is gone, restarting $unit"
|
|
restart_unit
|
|
return 0
|
|
fi
|
|
if ! ping_daemon; then
|
|
strike "daemon does not answer"
|
|
return 0
|
|
fi
|
|
if wait_for_window bar 3; then
|
|
rm -f "$fail_file"
|
|
return 0
|
|
fi
|
|
# Either nothing is open or the main loop is frozen (empty reply). Try to
|
|
# open the bar: a frozen daemon still won't list it afterwards.
|
|
open_bar || true
|
|
if wait_for_window bar 3; then
|
|
rm -f "$fail_file"
|
|
log "bar was missing, reopened"
|
|
else
|
|
strike "UI unresponsive"
|
|
fi
|
|
}
|
|
|
|
status() {
|
|
systemctl --user --no-pager status "$unit" 2>&1 | head -n 12 || true
|
|
printf '\nsocket listeners: %s(service main pid %s)\n' "$(socket_owners)" "$(main_pid)"
|
|
printf 'windows:\n'
|
|
list_windows | sed 's/^/ /'
|
|
printf 'screen: %s (requested: %s)\n' "$(current_screen)" "$(saved_screen)"
|
|
printf 'strikes: %s\n' "$(cat "$fail_file" 2>/dev/null || echo 0)"
|
|
}
|
|
|
|
case ${1:-} in
|
|
ensure) ensure ;;
|
|
open) shift; open_bar "$@" ;;
|
|
place) shift; open_bar --force "$@" ;;
|
|
close) close_bar ;;
|
|
reload) reload ;;
|
|
restart) restart_unit ;;
|
|
reset) reset ;;
|
|
check) check ;;
|
|
clean) clean ;;
|
|
focused) focused_monitor ;;
|
|
status) status ;;
|
|
-h | --help | help) usage ;;
|
|
*) usage >&2; exit 64 ;;
|
|
esac
|