Integrazione di dbus e KDE: avvio e arresto della parte di sessione di dbus con KDM.

Contenuti

Introduzione
Regolazione della configurazione di KDM
Avvio del sessiondaemon di dbus e rendere disponibili le variabili di ambiente.
2.1 Informazioni sui file di avvio di Bash.
2.2 Avvio della parte sessionbus di dbus
2.3 Arresto della parte sessionbus di dbus
2.4 Un utente è connesso più di una volta

0. Introduzione

Da qualche tempo molte applicazioni utilizzano D-BUS. Questo è il caso di KDE 3.5, l’attuale versione stabile di KDE. Con il prossimo KDE 4, D-BUS sta diventando sempre più importante, sostituendo DCOP.

In questo howto voglio descrivere un modo per avviare e fermare la parte di dbus dipendente dall’utente e dalla sessione. I principali obiettivi che ho in mente con questo approccio sono:

rendere disponibili le variabili di ambiente importanti per le applicazioni consapevoli di d-bus;
assicurarsi che la parte di sessione di dbus non venga avviata più di una volta per un singolo utente;
assicurarsi che la parte di sessione di dbus venga fermata quando una sessione di un utente termina;

Presumo che l’utente acceda con KDM, il gestore di accesso per KDE 3.5. La costruzione potrebbe essere utilizzata molto bene anche con altri gestori di accesso (XDM, GDM).
KDM ha la capacità di eseguire script all’inizio di una sessione (all’avvio) e alla fine (reset). Uno di essi può avviare (e fermare) la parte di sessione di dbus.

1. KDM: i file

KDM utilizza alcuni file per avviare e fermare:

. Xstartup
eseguito come root, dopo che un utente ha effettuato correttamente l’accesso.

. Xsession
esegue con i permessi dell’utente autorizzato, per avviare la sessione desiderata (KDE).

. Xreset
segnato come root, dopo che la sessione dell’utente è terminata.

Dove Xstartup è il posto per avviare le cose, Xreset è il posto per annullare questi comandi.

Per ulteriori informazioni su questi file, consulta il manuale di KDM.

Aggiungendo il seguente codice al file Xstartup:

-- snip --
for script in /etc/session.d/kdm/startup/*.sh; do
    if [ -x $script ]; then
        eval $script $USER kdm
    fi;
done;

e il codice al file Xreset:

-- snip --
for script in /etc/session.d/kdm/reset/*.sh; do
    if [ -x $script ]; then
        eval $script $USER kdm
    fi;
done;

Crea le directory in cui vanno gli script:

install -m755 -d /etc/session.d/kdm/startup  
install -m755 -d /etc/session.d/kdm/reset  
install -m755 -d /etc/session.d/scripts/start  
install -m755 -d /etc/session.d/scripts/stop

I file in queste directory devono essere accessibili a ogni utente ordinario: quindi i permessi sono 755.
Tutti gli script in queste directory dovrebbero avere gli stessi permessi: 755.

Ogni utente dovrebbe essere in grado di eseguire lo script, ma solo root è in grado di modificarli.

1. Avvio del sessiondaemon di dbus e rendere disponibili le variabili di ambiente

Il pacchetto dbus è suddiviso in due parti: una parte a livello di sistema e una per (ogni) sessione/utente. La parte a livello di sistema (un daemon) viene avviata all’avvio, con privilegi speciali di un utente dedicato. La parte a livello di sessione (anch’essa un daemon) deve essere avviata quando inizia una sessione per un utente e fermata quando la sessione termina.

La costruzione con kdm che sto usando qui è ideale per questo. Uno script nella directory di avvio per avviare il sessiondaemon per un utente, eseguendo con i privilegi di quell’utente, e uno nella directory di reset un altro script deve fermare quel daemon.

Ma non è così semplice. Alcune variabili (DBUS_SESSION_BUS_ADDRESS e DBUS_SESSION_BUS_PID) devono essere disponibili nell’ambiente per ogni applicazione che lavora con dbus. IMHO l’impostazione di queste variabili dovrebbe andare negli script di avvio di bash. Allora qualsiasi script o applicazione che stai eseguendo, queste variabili sono impostate sul valore corretto.

1.1 Informazioni sui file di avvio di Bash

Il sessiondaemon di dbus crea un file che contiene le variabili di ambiente. Come detto sopra, questo file dovrebbe essere letto (sourced) da bash quando si avvia per questo utente.

Quando bash viene avviato da “login” come una shell di accesso interattiva, legge /etc/profile e ~/.bash_profile. Bash viene anche avviato da “kdm”, e i file /etc/profile e ~/.bash_profile vengono sourced.

La mia idea è di memorizzare l’output del comando

dbus-launch --auto-syntax

nel file

$HOME/.dbus-session

Questo file è “sourced” quando bash si avvia. Questo non avviene automaticamente, ma dovrai aggiungere il seguente script a /etc/profile.d :

cat >> /etc/profile.d/dbus-session.sh << "EOF"
if [ -f $HOME/.dbus-session ]; then
        . $HOME/.dbus-session
fi;
EOF

In questo modo, le variabili di ambiente vengono rese disponibili quando Bash si avvia.

1.2 Avvio della parte sessionbus di dbus

Presumo che dbus sia installato e che venga avviato all’avvio.

Crea uno script nella directory /etc/session.d/scripts/start dbus-session-start.sh:

cd /etc/session.d/scripts/start

cat >> dbus-session-start.sh << "EOF"
#!/bin/bash
retcode=0;
userid=$1
userproperties=$(getent passwd | grep -m 1 -E "^$userid")
homedir=$(echo $userproperties | cut -d ":" -f 6);
gidnr=$(echo $userproperties | cut -d ":" -f 4);
uidnr=$(echo $userproperties | cut -d ":" -f 3);
if [ -d $homedir ]; then
    #
    # controlla se il dbus-daemon è già in esecuzione
    # il dbus-daemon deve essere avviato dall'utente (uidnr) che accede
    #
    
    if [ -f $homedir/.dbus-session ]; then
        # controlla se il dbus-daemon per questo utente è in esecuzione con il pid
        # nel file .dbus-session
 
        # pid secondo il comando ps
        ps_dbus_session_pid=$(ps aux | grep -m 1 -E "^$userid.*dbus-daemon.*session.*" 
        | grep -v "grep" | sed 's@[[:space:]][[:space:]]*@ @g' | cut -d " " -f 2)
        
        # leggi il pid dal file .dbus-session
        . $homedir/.dbus-session
        # controlla se sono gli stessi       
        if [ -z "$ps_dbus_session_pid" ]; then
            
            # dbus per questo utente non in esecuzione
            rm $homedir/.dbus-session
            
        elif [ $DBUS_SESSION_BUS_PID -ne $ps_dbus_session_pid ]; then
            
            # c'è qualcosa che non va: fermare il dbus-daemon per questo utente 
            # e rimuovere il file .dbus-session
            if [ $(id -u) -eq 0 ]; then
                sudo -H -u $userid sh -c "kill $ps_dbus_session_pid"
            elif [ $(id -u) -eq $uidnr ]; then
                kill -SIGTERM $ps_dbus_session_pid;
            fi
            rm $homedir/.dbus-session
            
        fi
    
    fi  
    if [ ! -f $homedir/.dbus-session ]; then
        # avvia solo una sessione dbus se il file .dbus-session non è trovato
        # nella home directory dell'utente  
  
        if [ $(id -u) -eq 0 ]; then
            sudo -u $userid -H /bin/sh -c "dbus-launch --auto-syntax > $homedir/.dbus-session"
            retcode=$?
            chown $uidnr:$gidnr $homedir/.dbus-session
        elif [ $(id -u) -eq $uidnr ]; then 
            dbus-launch --auto-syntax > $homedir/.dbus-session
            retcode=$?
        fi
    fi
fi;
if [ $retcode -ne 0 ]; then
    echo "Un errore con dbus ($retcode)."
fi;
exit $retcode
EOF


chmod --verbose --mode 755 /etc/session.d/scripts/start/dbus-session-start.sh  
ln -v -sf ../../scripts/start/dbus-session-start.sh /etc/session.d/kdm/startup/10dbus.sh

Questo script, eseguito da KDM all’avvio, avvierà il daemon di sessione dbus per questo utente e creerà il file .dbus-session nella home directory di questo utente, contenente tutte le variabili dbus.
Esso lo farà solo quando dbus non è già in esecuzione per questo utente.

Ora quando bash si avvia all’accesso, legge (sources) questo file.

Come puoi vedere, ho suddiviso l’avvio di dbus in due parti:

dbus-session-start.sh, eseguito quando inizia una sessione (kdm)
.dbus-session, sourced quando inizia una sessione (bash), potrebbe essere sourced più volte

Inoltre, utilizzo il parametro –auto-syntax, dove presumo venga utilizzato Bash. Quindi potrei usare qui –sh-syntax, ma funziona.

E Sudo è necessario per eseguire dbus-launcher come l’utente che sta accedendo, poiché KDM esegue questo script come root. (in realtà lo script controlla l’id dell’account che esegue questo script. Se è root (id = 0) allora viene utilizzato sudo per passare all’utente che avvia una sessione. Quando l’id e l’id dell’utente che accede sono gli stessi, non è necessario fare nulla.

2.3 Arresto della parte sessionbus di dbus

Creando lo script dbus-session-stop.sh nella directory di reset:

cd /etc/session.d/scripts/stop

cat >> dbus-session-stop.sh << "EOF"
#!/bin/bash
retcode=0;
userid=$1
userproperties=$(getent passwd | grep -m 1 -E "^$userid")
homedir=$(echo $userproperties | cut -d ":" -f 6);
gidnr=$(echo $userproperties | cut -d ":" -f 4);
uidnr=$(echo $userproperties | cut -d ":" -f 3);
        
if [ -f $homedir/.dbus-session ]; then
        
        . $homedir/.dbus-session
        
        if [ -n "$DBUS_SESSION_BUS_PID" ]; then
                if [ $(id -u) -eq 0 ]; then
                    sudo -u $userid -H /bin/sh -c "kill $DBUS_SESSION_BUS_PID"
                    retcode=$?
                    rm $homedir/.dbus-session
                elif [ $(id -u) -eq $uidnr ]; then
                    kill $DBUS_SESSION_BUS_PID
                    retcode=$?
                    rm $homedir/.dbus-session
                fi
        
        fi
fi;
if [ $retcode -ne 0 ]; then
    echo "Un errore con dbus ($retcode)."
fi;
exit $retcode
EOF


chmod --verbose --mode 755 dbus-session-stop.sh  
ln -v -sf ../../scripts/stop/dbus-session-stop.sh /etc/session.d/kdm/reset/90dbus.sh

Questo script ferma la parte di sessione del dbus-daemon.

2.4 Un utente è connesso più di una volta

Per la maggior parte delle situazioni questa costruzione è abbastanza buona. La maggior parte degli utenti ha una sessione alla volta. Ora, cosa succede quando un utente ha più sessioni contemporaneamente? È necessario avviare la parte di sessione di dbus per ogni sessione, o è sufficiente un’istanza?

Questa costruzione non consente più di un dbus-daemon per utente. Penso che dovrebbe essere abbastanza.

CHANGELOG:

[2006-01-18]

Howto iniziale
[2006-07-18]
Modificati gli script bash
[2006-09-09]
aggiunta verifica per vedere se il dbus-daemon è già in esecuzione per questo utente e se le informazioni trovate in .dbus-session sono corrette