Como executar o serviço do usuário do systemd para acionar no modo de suspensão (também conhecido como. suspender, hibernar)?

Question

Com base em várias fontes, reuni ~/.config/systemd/user/screenlock.service :

[Unit]
Description=Lock X session
Before=sleep.target

[Service]
Environment=DISPLAY=:0
ExecStart=/usr/bin/xautolock -locknow

[Install]
WantedBy=sleep.target

Eu o habilitei usando systemctl --user enable screenlock.service . Mas depois de reinicializar, logar, suspender e retomar (testamos ambos com systemctl suspend e fechando a tampa) a tela não está travada e não há nada em journalctl --user-unit screenlock.service . O que estou fazendo de errado?

A execução de DISPLAY=:0 /usr/bin/xautolock -locknow bloqueia a tela conforme o esperado.

$ systemctl --version
systemd 215
+PAM -AUDIT -SELINUX -IMA -SYSVINIT +LIBCRYPTSETUP +GCRYPT +ACL +XZ +SECCOMP -APPARMOR
$ awesome --version
awesome v3.5.5 (Kansas City Shuffle)
 • Build: Apr 11 2014 09:36:33 for x86_64 by gcc version 4.8.2 (nobody@)
 • Compiled against Lua 5.2.3 (running with Lua 5.2)
 • D-Bus support: ✔
$ slim -v
slim version 1.3.6

Se eu executar systemctl --user start screenlock.service a tela é bloqueada imediatamente e recebo uma mensagem de log em journalctl --user-unit screenlock.service , então ExecStart está correto.

Relevante .xinitrc seção :

xautolock -locker slock &

Criar um serviço de sistema com o mesmo arquivo funciona (isto é, slock está ativo ao continuar):

# ln -s "${HOME}/.config/systemd/user/screenlock.service" /usr/lib/systemd/system/screenlock.service
# systemctl enable screenlock.service
$ systemctl suspend

Mas não quero adicionar um arquivo específico do usuário fora de $HOME por diversos motivos:

• Os serviços do usuário devem ser claramente separados dos serviços do sistema
• Os serviços do usuário devem ser controlados sem o uso de privilégios de superusuário
• A configuração deve ser facilmente controlada por versão

Answer 1

sleep.target é específico para serviços do sistema. O motivo é que sleep.target não é um alvo mágico que é ativado automaticamente quando vai dormir. É apenas um alvo regular que coloca o sistema para dormir - então as instâncias de 'usuário' obviamente não terão um equivalente. (E, infelizmente, as instâncias de 'usuário' atualmente não têm como depender de serviços em todo o sistema.)

(Isso, e há todo o negócio "hardcoding $ DISPLAY". Toda vez que você codifica parâmetros de sessão em um SO baseado no Unix multiusuário / multi-usuário, o root mata um gatinho.)

Portanto, há duas boas maneiras de fazer isso (sugiro o segundo):

Método 1

Crie um serviço do sistema (ou um gancho systemd-sleep (8)) que faça o systemd-logind transmitir o sinal "bloquear todas as sessões" quando o sistema entrar no modo de suspensão:

ExecStart=/usr/bin/loginctl lock-sessions

Em seguida, na sua sessão X11 (por exemplo, de ~ / .xinitrc), execute algo que reaja ao sinal:

systemd-lock-handler slock &

xss-lock --ignore-sleep slock &

(GNOME, Canela, KDE, Iluminismo já suportam isso nativamente.)

Método 2

Na sua sessão do X11, execute algo que diretamente procura o sistema entrar em suspensão, por exemplo, ligando-se aos "inibidores" do systemd-logind.

O xss-lock mencionado acima faz exatamente isso, mesmo sem o sinal "lock all" explícito, então é suficiente tê-lo em execução:

xss-lock slock &

Ele executará slock assim que o systemd-logind estiver se preparando para suspender o computador.

    

Answer 2

systemd-lock-handler é um script Python que pode fazer isso: link .

#!/usr/bin/env python
# systemd-lock-handler -- proxy between systemd-logind's "Lock" signal and your
#   favourite screen lock command

from __future__ import print_function
import os, sys, dbus, dbus.mainloop.glib
from gi.repository import GLib

def trace(*args):
    global arg0
    print("%s:" % arg0, *args)

def setup_signal(signal_handler):
    global session_id
    bus = dbus.SystemBus()
    manager = bus.get_object("org.freedesktop.login1", "/org/freedesktop/login1")
    # yecch
    manager = dbus.Interface(manager, "org.freedesktop.login1.Manager")
    session_path = manager.GetSession(session_id)
    session = bus.get_object("org.freedesktop.login1", session_path)
    session.connect_to_signal("Lock", signal_handler)

def handler_dbus_fdo():
    trace("locking session using DBus")
    bus = dbus.SessionBus()
    screensaver = bus.get_object("org.freedesktop.ScreenSaver", "/ScreenSaver")
    screensaver.Lock()

def handler_external():
    global lock_command
    trace("locking session using %r" % lock_command[0])
    os.spawnvp(os.P_NOWAIT, lock_command[0], lock_command)

def main():
    global arg0, lock_command, session_id
    arg0 = sys.argv[0].split("/")[-1]
    lock_command = sys.argv[1:] or ["--dbus"]
    try:
        session_id = os.environ["XDG_SESSION_ID"]
    except KeyError:
        print("error: $XDG_SESSION_ID not set; are you using pam_systemd?",
            file=sys.stderr)
        sys.exit(1)
    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
    if lock_command == ["--dbus"]:
        trace("using freedesktop.org DBus API")
        setup_signal(handler_dbus_fdo)
    else:
        trace("using external command %r" % lock_command[0])
        setup_signal(handler_external)
    trace("waiting for lock signals on session %s" % session_id)
    try:
        loop = GLib.MainLoop()
        loop.run()
    except KeyboardInterrupt:
        sys.exit(0)

main()