612 lines
18 KiB
Python
612 lines
18 KiB
Python
#!/usr/bin/python3
|
|
"""Apply the standard KDE Plasma settings used on the VDI clients.
|
|
|
|
The settings are intentionally model-independent:
|
|
|
|
* Touchpad settings are written to KWin's global ``[Libinput][Defaults][Touchpad]``
|
|
group, so they apply to every touchpad regardless of vendor/product/name.
|
|
* PowerDevil is configured for AC, battery and low-battery profiles.
|
|
* KScreenLocker is configured not to lock automatically.
|
|
|
|
The module can be run in two modes:
|
|
|
|
* as root (default): write the system-wide defaults, update every user in
|
|
/home, install the session helper and apply the settings to any user who is
|
|
currently logged in;
|
|
* ``--session``: run as the logged-in user from the XDG autostart entry. It
|
|
applies the settings to the running KWin/PowerDevil/KScreenLocker session.
|
|
|
|
All operations are idempotent. Only the keys listed below are touched; other
|
|
user settings are preserved.
|
|
"""
|
|
|
|
import json
|
|
import logging
|
|
import os
|
|
import pwd
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
from pathlib import Path
|
|
|
|
logger = logging.getLogger("vdi-kde-settings")
|
|
|
|
KWRITE = shutil.which("kwriteconfig6")
|
|
KREAD = shutil.which("kreadconfig6")
|
|
BUSCTL = shutil.which("busctl")
|
|
RUNUSER = shutil.which("runuser")
|
|
SUDO = shutil.which("sudo")
|
|
|
|
SYSTEM_CONFIG_DIR = Path("/etc/xdg")
|
|
HELPER_PATH = Path("/usr/local/bin/vdi-kde-settings")
|
|
AUTOSTART_DIR = Path("/etc/xdg/autostart")
|
|
AUTOSTART_FILE = AUTOSTART_DIR / "vdi-kde-settings.desktop"
|
|
LEGACY_TOUCHPAD_CONFIG = Path("/etc/X11/xorg.conf.d/90-libinput-touchpad.conf")
|
|
LEGACY_DPMS_SCRIPT = Path("/etc/profile.d/disable-dpms.sh")
|
|
LEGACY_SDDM_CONFIG = Path("/etc/sddm.conf.d/10-x11-only.conf")
|
|
|
|
TOUCHPAD_GROUP = ("Libinput", "Defaults", "Touchpad")
|
|
TOUCHPAD_SETTINGS = (
|
|
# Match the old Xorg InputClass settings: tapping, natural scrolling,
|
|
# disable-while-typing and clickfinger.
|
|
("TapToClick", "true", "bool"),
|
|
("NaturalScroll", "true", "bool"),
|
|
("DisableWhileTyping", "true", "bool"),
|
|
("ClickMethod", "2", None), # 2 == clickfinger
|
|
)
|
|
|
|
POWER_PROFILES = ("AC", "Battery", "LowBattery")
|
|
POWER_DISPLAY_SETTINGS = (
|
|
# "Never" in the PowerDevil KCM.
|
|
("DimDisplayWhenIdle", "false", "bool"),
|
|
("DimDisplayIdleTimeoutSec", "-1", None),
|
|
("TurnOffDisplayWhenIdle", "false", "bool"),
|
|
("TurnOffDisplayIdleTimeoutSec", "-1", None),
|
|
("LockBeforeTurnOffDisplay", "false", "bool"),
|
|
)
|
|
POWER_SUSPEND_SETTINGS = (
|
|
# No automatic suspend.
|
|
("AutoSuspendAction", "0", None), # 0 == NoAction
|
|
("AutoSuspendIdleTimeoutSec", "0", None),
|
|
)
|
|
|
|
LOCK_GROUP = ("Daemon",)
|
|
LOCK_SETTINGS = (
|
|
("Autolock", "false", "bool"),
|
|
("Timeout", "0", None),
|
|
("LockOnResume", "false", "bool"),
|
|
("LockOnStart", "false", "bool"),
|
|
)
|
|
|
|
AUTOSTART_CONTENT = """[Desktop Entry]
|
|
Type=Application
|
|
Name=VDI KDE Settings
|
|
Comment=Apply the standard VDI touchpad, power and screen-lock settings
|
|
Exec=/usr/local/bin/vdi-kde-settings --session
|
|
Terminal=false
|
|
NoDisplay=true
|
|
OnlyShowIn=KDE;
|
|
X-KDE-autostart-phase=2
|
|
"""
|
|
|
|
|
|
def _config_sections():
|
|
"""Return [(filename, [((group...), ((key, value, type), ...)), ...])]."""
|
|
sections = [("kcminputrc", [(TOUCHPAD_GROUP, TOUCHPAD_SETTINGS)])]
|
|
|
|
power_sections = []
|
|
for profile in POWER_PROFILES:
|
|
power_sections.append(((profile, "Display"), POWER_DISPLAY_SETTINGS))
|
|
power_sections.append(((profile, "SuspendAndShutdown"), POWER_SUSPEND_SETTINGS))
|
|
sections.append(("powerdevilrc", power_sections))
|
|
sections.append(("kscreenlockerrc", [(LOCK_GROUP, LOCK_SETTINGS)]))
|
|
return sections
|
|
|
|
|
|
def _kconfig_args(command, path, groups, key=None):
|
|
args = [command, "--file", str(path)]
|
|
for group in groups:
|
|
args.extend(["--group", group])
|
|
if key is not None:
|
|
args.extend(["--key", key])
|
|
return args
|
|
|
|
|
|
def _kconfig_get(path, groups, key):
|
|
if not KREAD:
|
|
return None
|
|
try:
|
|
result = subprocess.run(
|
|
_kconfig_args(KREAD, path, groups, key),
|
|
check=False,
|
|
capture_output=True,
|
|
text=True,
|
|
)
|
|
except OSError:
|
|
return None
|
|
if result.returncode != 0:
|
|
return None
|
|
return result.stdout.strip()
|
|
|
|
|
|
def _kconfig_set(path, groups, key, value, type_name):
|
|
if not KWRITE:
|
|
logger.warning("kwriteconfig6 is not installed; cannot write %s", path)
|
|
return False
|
|
|
|
args = _kconfig_args(KWRITE, path, groups, key)
|
|
if type_name == "bool":
|
|
args.extend(["--type", "bool"])
|
|
# Values such as "-1" must not be interpreted as command line options.
|
|
args.extend(["--", value])
|
|
|
|
try:
|
|
result = subprocess.run(args, check=False, capture_output=True, text=True)
|
|
except OSError as error:
|
|
logger.warning("Could not run kwriteconfig6: %s", error)
|
|
return False
|
|
if result.returncode != 0:
|
|
logger.warning(
|
|
"Could not write %s [%s] %s: %s",
|
|
path,
|
|
"][".join(groups),
|
|
key,
|
|
result.stderr.strip(),
|
|
)
|
|
return False
|
|
return True
|
|
|
|
|
|
def _ensure_key(path, groups, key, value, type_name):
|
|
"""Write a key only if it differs from the requested value."""
|
|
current = _kconfig_get(path, groups, key)
|
|
if current == value:
|
|
return False
|
|
return _kconfig_set(path, groups, key, value, type_name)
|
|
|
|
|
|
def _ensure_config(path, sections, owner=None):
|
|
changed = False
|
|
for groups, settings in sections:
|
|
for key, value, type_name in settings:
|
|
if _ensure_key(path, groups, key, value, type_name):
|
|
changed = True
|
|
|
|
if path.exists() and owner is not None:
|
|
stat = path.stat()
|
|
if stat.st_uid != owner[0] or stat.st_gid != owner[1]:
|
|
try:
|
|
os.chown(path, owner[0], owner[1])
|
|
except OSError as error:
|
|
logger.warning("Could not change owner of %s: %s", path, error)
|
|
return changed
|
|
|
|
|
|
def ensure_system_configs():
|
|
"""Write the system-wide defaults below /etc/xdg."""
|
|
try:
|
|
SYSTEM_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
|
|
except OSError as error:
|
|
logger.warning("Could not create %s: %s", SYSTEM_CONFIG_DIR, error)
|
|
return
|
|
|
|
for filename, sections in _config_sections():
|
|
path = SYSTEM_CONFIG_DIR / filename
|
|
_ensure_config(path, sections, owner=(0, 0))
|
|
# kwriteconfig6 creates files with mode 0600; system-wide defaults must
|
|
# be readable by the user sessions.
|
|
if path.exists():
|
|
try:
|
|
os.chmod(path, 0o644)
|
|
except OSError as error:
|
|
logger.warning("Could not change mode of %s: %s", path, error)
|
|
|
|
|
|
def install_helper():
|
|
"""Install the session helper and its XDG autostart entry."""
|
|
try:
|
|
source = Path(__file__).resolve()
|
|
target = HELPER_PATH.resolve()
|
|
if source != target:
|
|
HELPER_PATH.parent.mkdir(parents=True, exist_ok=True)
|
|
temporary = HELPER_PATH.with_name(HELPER_PATH.name + ".tmp")
|
|
shutil.copy2(source, temporary)
|
|
os.chmod(temporary, 0o755)
|
|
os.chown(temporary, 0, 0)
|
|
os.replace(temporary, HELPER_PATH)
|
|
else:
|
|
os.chmod(HELPER_PATH, 0o755)
|
|
os.chown(HELPER_PATH, 0, 0)
|
|
except OSError as error:
|
|
logger.warning("Could not install %s: %s", HELPER_PATH, error)
|
|
return
|
|
|
|
try:
|
|
AUTOSTART_DIR.mkdir(parents=True, exist_ok=True)
|
|
current = AUTOSTART_FILE.read_text() if AUTOSTART_FILE.exists() else None
|
|
if current != AUTOSTART_CONTENT:
|
|
temporary = AUTOSTART_FILE.with_name(AUTOSTART_FILE.name + ".tmp")
|
|
temporary.write_text(AUTOSTART_CONTENT)
|
|
os.chmod(temporary, 0o644)
|
|
os.chown(temporary, 0, 0)
|
|
os.replace(temporary, AUTOSTART_FILE)
|
|
if AUTOSTART_FILE.exists():
|
|
os.chmod(AUTOSTART_FILE, 0o644)
|
|
os.chown(AUTOSTART_FILE, 0, 0)
|
|
except OSError as error:
|
|
logger.warning("Could not install %s: %s", AUTOSTART_FILE, error)
|
|
|
|
|
|
def ensure_user_configs(user):
|
|
"""Write the settings into a user's ~/.config, preserving other keys."""
|
|
home = Path(user.pw_dir)
|
|
if not home.is_dir():
|
|
return False
|
|
|
|
config_dir = home / ".config"
|
|
created = False
|
|
if not config_dir.is_dir():
|
|
try:
|
|
config_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
|
|
created = True
|
|
except OSError as error:
|
|
logger.warning("Could not create %s: %s", config_dir, error)
|
|
return False
|
|
if created:
|
|
try:
|
|
os.chown(config_dir, user.pw_uid, user.pw_gid)
|
|
except OSError as error:
|
|
logger.warning("Could not change owner of %s: %s", config_dir, error)
|
|
|
|
changed = False
|
|
for filename, sections in _config_sections():
|
|
path = config_dir / filename
|
|
if _ensure_config(path, sections, owner=(user.pw_uid, user.pw_gid)):
|
|
changed = True
|
|
return changed
|
|
|
|
|
|
def system_users():
|
|
"""Yield the regular users whose home is below /home."""
|
|
home_root = Path("/home")
|
|
if not home_root.is_dir():
|
|
return
|
|
|
|
for entry in sorted(home_root.iterdir()):
|
|
if not entry.is_dir():
|
|
continue
|
|
try:
|
|
user = pwd.getpwnam(entry.name)
|
|
except KeyError:
|
|
continue
|
|
if user.pw_uid < 1000:
|
|
continue
|
|
if Path(user.pw_dir).resolve() != entry.resolve():
|
|
continue
|
|
if user.pw_shell.endswith(("nologin", "false")):
|
|
continue
|
|
yield user
|
|
|
|
|
|
def _session_bus(user):
|
|
runtime = Path(f"/run/user/{user.pw_uid}")
|
|
return runtime, runtime / "bus"
|
|
|
|
|
|
def _session_env(user):
|
|
runtime, bus = _session_bus(user)
|
|
env = os.environ.copy()
|
|
env["XDG_RUNTIME_DIR"] = str(runtime)
|
|
env["DBUS_SESSION_BUS_ADDRESS"] = f"unix:path={bus}"
|
|
return env
|
|
|
|
|
|
def _busctl(args, env):
|
|
if not BUSCTL:
|
|
return None
|
|
try:
|
|
return subprocess.run(
|
|
[BUSCTL, "--user"] + args,
|
|
env=env,
|
|
check=False,
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=15,
|
|
)
|
|
except (OSError, subprocess.TimeoutExpired):
|
|
return None
|
|
|
|
|
|
def _busctl_ok(args, env):
|
|
result = _busctl(args, env)
|
|
return result is not None and result.returncode == 0
|
|
|
|
|
|
def _kwin_devices(env):
|
|
result = _busctl(
|
|
[
|
|
"--json=short",
|
|
"get-property",
|
|
"org.kde.KWin",
|
|
"/org/kde/KWin/InputDevice",
|
|
"org.kde.KWin.InputDeviceManager",
|
|
"devicesSysNames",
|
|
],
|
|
env,
|
|
)
|
|
if result is None or result.returncode != 0:
|
|
return None
|
|
try:
|
|
return json.loads(result.stdout).get("data", [])
|
|
except (json.JSONDecodeError, AttributeError):
|
|
return None
|
|
|
|
|
|
def _kwin_property(env, path, name):
|
|
result = _busctl(
|
|
[
|
|
"--json=short",
|
|
"get-property",
|
|
"org.kde.KWin",
|
|
path,
|
|
"org.kde.KWin.InputDevice",
|
|
name,
|
|
],
|
|
env,
|
|
)
|
|
if result is None or result.returncode != 0:
|
|
return None
|
|
try:
|
|
return json.loads(result.stdout).get("data")
|
|
except (json.JSONDecodeError, AttributeError):
|
|
return None
|
|
|
|
|
|
def _set_kwin_bool(env, path, name, value=True):
|
|
current = _kwin_property(env, path, name)
|
|
if current is value:
|
|
return False
|
|
result = _busctl(
|
|
[
|
|
"set-property",
|
|
"org.kde.KWin",
|
|
path,
|
|
"org.kde.KWin.InputDevice",
|
|
name,
|
|
"b",
|
|
"true" if value else "false",
|
|
],
|
|
env,
|
|
)
|
|
if result is None or result.returncode != 0:
|
|
return False
|
|
return True
|
|
|
|
|
|
def _apply_touchpad(env, sysname):
|
|
path = f"/org/kde/KWin/InputDevice/{sysname}"
|
|
if _kwin_property(env, path, "touchpad") is not True:
|
|
return
|
|
|
|
name = _kwin_property(env, path, "name") or sysname
|
|
changed = False
|
|
for prop, support_prop in (
|
|
("tapToClick", None),
|
|
("naturalScroll", "supportsNaturalScroll"),
|
|
("disableWhileTyping", "supportsDisableWhileTyping"),
|
|
("clickMethodClickfinger", "supportsClickMethodClickfinger"),
|
|
):
|
|
if support_prop is not None and _kwin_property(env, path, support_prop) is False:
|
|
continue
|
|
if _set_kwin_bool(env, path, prop):
|
|
changed = True
|
|
|
|
if changed:
|
|
logger.info("Applied touchpad settings to %s (%s)", name, sysname)
|
|
|
|
|
|
def _emit_kwin_reload(env):
|
|
_busctl_ok(
|
|
[
|
|
"emit",
|
|
"/KGlobalSettings",
|
|
"org.kde.KGlobalSettings",
|
|
"notifyChange",
|
|
"ii",
|
|
"3",
|
|
"0",
|
|
],
|
|
env,
|
|
)
|
|
|
|
|
|
def apply_session():
|
|
"""Apply settings to the current graphical session (run as the user)."""
|
|
try:
|
|
user = pwd.getpwuid(os.getuid())
|
|
except KeyError:
|
|
logger.error("Could not determine the current user")
|
|
return 1
|
|
|
|
try:
|
|
ensure_user_configs(user)
|
|
except Exception:
|
|
logger.exception("Could not update the user configuration")
|
|
|
|
env = _session_env(user)
|
|
_runtime, bus = _session_bus(user)
|
|
if not bus.exists():
|
|
logger.info("No session bus for %s; skipping live KDE settings", user.pw_name)
|
|
return 0
|
|
|
|
# KWin and PowerDevil may still be starting when the autostart entry runs.
|
|
devices = None
|
|
deadline = time.monotonic() + 15
|
|
while time.monotonic() < deadline:
|
|
devices = _kwin_devices(env)
|
|
if devices is not None:
|
|
break
|
|
time.sleep(0.5)
|
|
|
|
if devices is None:
|
|
logger.warning("KWin input devices are not available yet")
|
|
else:
|
|
# Let KWin re-read kcminputrc, then force the values on every touchpad
|
|
# so that stale per-device entries from older versions are corrected.
|
|
_emit_kwin_reload(env)
|
|
for sysname in devices:
|
|
_apply_touchpad(env, sysname)
|
|
|
|
_busctl_ok(
|
|
[
|
|
"call",
|
|
"org.kde.Solid.PowerManagement",
|
|
"/org/kde/Solid/PowerManagement",
|
|
"org.kde.Solid.PowerManagement",
|
|
"refreshStatus",
|
|
],
|
|
env,
|
|
)
|
|
_busctl_ok(
|
|
[
|
|
"call",
|
|
"org.kde.screensaver",
|
|
"/ScreenSaver",
|
|
"org.kde.screensaver",
|
|
"configure",
|
|
],
|
|
env,
|
|
)
|
|
return 0
|
|
|
|
|
|
def _run_session_helper(user):
|
|
if not HELPER_PATH.exists():
|
|
return
|
|
# Prefer sudo: it also performs the SELinux context transition to the
|
|
# target user, which is needed to connect to that user's session bus from
|
|
# a root cron job on Fedora.
|
|
if SUDO:
|
|
# -n: never prompt. Root does not need a password; this only prevents a
|
|
# stuck cron job if sudo is misconfigured.
|
|
runner = [SUDO, "-n", "-u", user.pw_name, "--"]
|
|
elif RUNUSER:
|
|
runner = [RUNUSER, "-u", user.pw_name, "--"]
|
|
else:
|
|
logger.warning("Neither sudo nor runuser is available; cannot run session helper")
|
|
return
|
|
|
|
runtime, _bus = _session_bus(user)
|
|
command = runner + [
|
|
"/usr/bin/env",
|
|
f"HOME={user.pw_dir}",
|
|
f"XDG_RUNTIME_DIR={runtime}",
|
|
f"DBUS_SESSION_BUS_ADDRESS=unix:path={runtime}/bus",
|
|
"PATH=/usr/local/bin:/usr/bin:/bin",
|
|
str(HELPER_PATH),
|
|
"--session",
|
|
]
|
|
try:
|
|
result = subprocess.run(
|
|
command, check=False, capture_output=True, text=True, timeout=45
|
|
)
|
|
except (OSError, subprocess.TimeoutExpired) as error:
|
|
logger.warning("Could not apply settings for %s: %s", user.pw_name, error)
|
|
return
|
|
if result.returncode != 0:
|
|
logger.warning(
|
|
"Session helper failed for %s: %s",
|
|
user.pw_name,
|
|
result.stderr.strip(),
|
|
)
|
|
|
|
|
|
def _remove_legacy_file(path, description):
|
|
if not path.exists() and not path.is_symlink():
|
|
return
|
|
try:
|
|
path.unlink()
|
|
logger.info("Removed legacy %s (%s)", description, path)
|
|
except OSError as error:
|
|
logger.warning("Could not remove %s: %s", path, error)
|
|
|
|
|
|
def cleanup_legacy_config():
|
|
"""Remove the old X11/SDDM-only provisioning files."""
|
|
_remove_legacy_file(LEGACY_TOUCHPAD_CONFIG, "Xorg touchpad configuration")
|
|
_remove_legacy_file(LEGACY_DPMS_SCRIPT, "xset DPMS script")
|
|
_remove_legacy_file(LEGACY_SDDM_CONFIG, "X11-only SDDM configuration")
|
|
|
|
skel_link = Path("/etc/skel/.config/autostart-scripts/disable-dpms.sh")
|
|
_remove_legacy_file(skel_link, "xset autostart symlink")
|
|
|
|
# Older versions of the provisioning script disabled the Wayland session
|
|
# by renaming its desktop file.
|
|
disabled = Path("/usr/share/wayland-sessions/plasmawayland.desktop.disabled")
|
|
current = Path("/usr/share/wayland-sessions/plasmawayland.desktop")
|
|
plasma = Path("/usr/share/wayland-sessions/plasma.desktop")
|
|
if disabled.exists():
|
|
try:
|
|
if current.exists() or plasma.exists():
|
|
disabled.unlink()
|
|
else:
|
|
disabled.rename(current)
|
|
logger.info("Restored the Wayland session entry")
|
|
except OSError as error:
|
|
logger.warning("Could not restore the Wayland session entry: %s", error)
|
|
|
|
|
|
def cleanup_user_legacy(user):
|
|
link = Path(user.pw_dir) / ".config/autostart-scripts/disable-dpms.sh"
|
|
if not link.is_symlink():
|
|
return
|
|
try:
|
|
target = os.readlink(link)
|
|
except OSError:
|
|
return
|
|
if target == str(LEGACY_DPMS_SCRIPT) or "disable-dpms.sh" in target:
|
|
_remove_legacy_file(link, "user xset autostart symlink")
|
|
|
|
|
|
def apply_all():
|
|
"""Root entry point: write defaults and update all users."""
|
|
if os.geteuid() != 0:
|
|
logger.error("This mode must be run as root")
|
|
return 1
|
|
|
|
cleanup_legacy_config()
|
|
install_helper()
|
|
ensure_system_configs()
|
|
|
|
for user in system_users():
|
|
try:
|
|
ensure_user_configs(user)
|
|
except Exception:
|
|
logger.exception("Could not update configuration for %s", user.pw_name)
|
|
|
|
try:
|
|
cleanup_user_legacy(user)
|
|
except Exception:
|
|
logger.exception("Could not clean up legacy files for %s", user.pw_name)
|
|
|
|
_runtime, bus = _session_bus(user)
|
|
if bus.exists():
|
|
_run_session_helper(user)
|
|
|
|
return 0
|
|
|
|
|
|
def main():
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format="%(asctime)s - %(levelname)s - %(message)s",
|
|
)
|
|
if "--session" in sys.argv[1:]:
|
|
return apply_session()
|
|
return apply_all()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|