Come rilevare l'ambiente desktop in uno script bash?

Sto scrivendo uno bashscript che deve sapere quale ambiente desktop (XFCE, Unity, KDE, LXDE, Mate, Cinnamon, GNOME2, GNOME3, ...) è in esecuzione.

Come posso ottenere tali informazioni?

Il problema principale con il controllo DESKTOP_SESSIONè che è impostato dal display manager piuttosto che dalla sessione desktop ed è soggetto a incongruenze. Per lightdmDebian, i valori provengono dai nomi dei file in /usr/share/xsessions/. DESKTOP_SESSIONriflette l'ambiente desktop se viene effettuata una selezione specifica all'accesso, tuttavia lightdm-xsessionviene sempre utilizzata la sessione predefinita.

GDMSESSIONè un'altra opzione, ma sembra avere una situazione simile (è lo stesso valore DESKTOP_SESSIONper me).

XDG_CURRENT_DESKTOPsembra una buona scelta, tuttavia non è attualmente nello standard XDG e quindi non sempre implementato. Vedi qui per una discussione di questo. Questa risposta mostra i suoi valori per diverse distro / desktop, posso anche confermare che al momento non è disponibile per me su XFCE.

Il fallback ragionevole per XDG_CURRENT_DESKTOPnon esistere sarebbe provare XDG_DATA_DIRS. Se i file di dati per l'ambiente desktop sono installati in una directory che porta il suo nome, questo approccio dovrebbe funzionare. Speriamo che questo sia il caso di tutte le distro / desktop!

I seguenti test (con GNU grep) per XFCE, KDE e Gnome:

echo "$XDG_DATA_DIRS" | grep -Eo 'xfce|kde|gnome'

POSIX compatibile:

echo "$XDG_DATA_DIRS" | sed 's/.*\(xfce\|kde\|gnome\).*/\1/'

Da combinare con il controllo XDG_CURRENT_DESKTOP:

if [ "$XDG_CURRENT_DESKTOP" = "" ]
then
  desktop=$(echo "$XDG_DATA_DIRS" | sed 's/.*\(xfce\|kde\|gnome\).*/\1/')
else
  desktop=$XDG_CURRENT_DESKTOP
fi

desktop=${desktop,,}  # convert to lower case
echo "$desktop"

Metodo n. 1 - $ DESKTOP_SESSION

Penso che puoi scoprirlo interrogando la variabile d'ambiente $DESKTOP_SESSION. Non sono del tutto sicuro di quanto ampiamente sia supportato, ma nei miei test limitati sembra essere disponibile su Fedora e Ubuntu.

$ echo $DESKTOP_SESSION
gnome

Un'altra scelta è la $XDG_SESSION_DESKTOPvariabile.

Metodo n. 2 - wmctrl

C'è anche questo metodo che fa uso di wmctrl.

$ wmctrl  -m
Name: GNOME Shell
Class: N/A
PID: N/A
Window manager's "showing the desktop" mode: N/A

Riferimenti

• Come determinare quale gestore delle finestre è in esecuzione

Puoi usare questo script bash . Può rilevare il nome e la versione dell'ambiente desktop.

#!/bin/bash

function detect_gnome()
{
    ps -e | grep -E '^.* gnome-session$' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi
    VERSION=`gnome-session --version | awk '{print $2}'`
    DESKTOP="GNOME"
    return 1
}

function detect_kde()
{
    ps -e | grep -E '^.* kded4$' > /dev/null
    if [ $? -ne 0 ];
    then
        return 0
    else    
        VERSION=`kded4 --version | grep -m 1 'KDE' | awk -F ':' '{print $2}' | awk '{print $1}'`
        DESKTOP="KDE"
        return 1
    fi
}

function detect_unity()
{
    ps -e | grep -E 'unity-panel' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi
    VERSION=`unity --version | awk '{print $2}'`
    DESKTOP="UNITY"
    return 1
}

function detect_xfce()
{
    ps -e | grep -E '^.* xfce4-session$' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi
    VERSION=`xfce4-session --version | grep xfce4-session | awk '{print $2}'`
    DESKTOP="XFCE"
    return 1
}

function detect_cinnamon()
{
    ps -e | grep -E '^.* cinnamon$' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi
    VERSION=`cinnamon --version | awk '{print $2}'`
    DESKTOP="CINNAMON"
    return 1
}

function detect_mate()
{
    ps -e | grep -E '^.* mate-panel$' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi
    VERSION=`mate-about --version | awk '{print $4}'`
    DESKTOP="MATE"
    return 1
}

function detect_lxde()
{
    ps -e | grep -E '^.* lxsession$' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi

    # We can detect LXDE version only thru package manager
    which apt-cache > /dev/null 2> /dev/null
    if [ $? -ne 0 ];
    then
    which yum > /dev/null 2> /dev/null
    if [ $? -ne 0 ];
    then
        VERSION='UNKNOWN'
    else
        # For Fedora
        VERSION=`yum list lxde-common | grep lxde-common | awk '{print $2}' | awk -F '-' '{print $1}'`
    fi
    else    
    # For Lubuntu and Knoppix
    VERSION=`apt-cache show lxde-common /| grep 'Version:' | awk '{print $2}' | awk -F '-' '{print $1}'`
    fi
    DESKTOP="LXDE"
    return 1
}

function detect_sugar()
{
    if [ "$DESKTOP_SESSION" == "sugar" ];
    then
    VERSION=`python -c "from jarabe import config; print config.version"`
    DESKTOP="SUGAR"
    else
    return 0
    fi
}


DESKTOP="UNKNOWN"
if detect_unity;
then
    if detect_kde;
    then
    if detect_gnome;
    then
        if detect_xfce;
        then
        if detect_cinnamon;
        then
            if detect_mate;
            then
            if detect_lxde;
            then
                detect_sugar
            fi
            fi
        fi
        fi
    fi
    fi
fi


if [ "$1" == '-v' ];
then
    echo $VERSION
else
    if [ "$1" == '-n' ];
    then
    echo $DESKTOP
    else
    echo $DESKTOP $VERSION
    fi
fi

Ciò dipende probabilmente dalla situazione. Se sai quale display manager viene utilizzato, è possibile che questo inserisca queste informazioni in una variabile di ambiente.

In caso contrario, suppongo che si debba verificare ogni DE che si desidera poter identificare. Tutti dovrebbero introdurre le proprie variabili d'ambiente.

Se la variabile ambientale XDG_CURRENT_DESKTOPè disponibile, dovrebbe dirlo.

# echo $XDG_CURRENT_DESKTOP
KDE

Potresti cercare Xorgprocessi in esecuzione . Il genitore di questo dovrebbe essere il tuo display manager. I suoi discendenti dovrebbero dare un'indicazione di quale ambiente desktop è in esecuzione. Sul mio sistema, il display manager si esegue da solo (con parametri diversi). Questo allora depone le uova x-session-manager, che è collegato simbolicamente a xfce4-session. Questo può essere sufficiente, ma tutti i figli di questo sono legati al mio ambiente desktop. Trovarli tramite l'albero dei processi dovrebbe essere il modo migliore per escludere elementi di altri sistemi di finestre avviati da vari programmi (o forse deliberatamente).

Il mio primo pensiero è stato che sarebbe meglio cercare il gestore di finestre associato al proprio ambiente desktop, ma spesso è possibile configurarne uno diverso per l'esecuzione (ad esempio xmonadin Gnome), quindi non è affidabile. Il migliore da cercare è probabilmente quello che gestisce il desktop reale, ad esempio xfdesktopo qualsiasi elemento dell'ambiente desktop di cui hai effettivamente bisogno per far funzionare il tuo script :)

Esempio

Ecco un esempio usando procps-ng ( -Ce --ppidnon sono POSIX). Presuppone che sia solo un'istanza di Xorg.

Questo è solo un esempio che funziona per il desktop xfce. Un esempio di lavoro completo richiede un'indagine sui processi utilizzati da ciascun sistema desktop, così come la maggior parte delle altre soluzioni richiede un'indagine su come le variabili ambientali sono impostate in vari altri sistemi desktop.

X=Xorg

search_descendants ()
{
  ps h -o comm --ppid $1 |
    grep -E '^(xfdesktop|another_desktop_process)$' &&
    return 0

  for pid in $(ps h -o pid --ppid $1)
  do
    search_descendants $pid && return 0
  done

  return 1
}

dm_pid=$(ps h -o ppid -C "$X")

case "$(search_descendants $dm_pid)" in
  xfdesktop)
    desktop=xfce
    ;;
  another_desktop_process)
    desktop=another_desktop
    ;;
  *)
    desktop=unknown
    ;;
esac

echo $desktop

Da tutti gli esperimenti riportati nei numerosi commenti, penso che sia mio dovere come PO presentare una risposta di consenso. (State tranquilli, sarei felice di rivedere questa risposta se fossero disponibili dati contrastanti.)

Per ora, sembra meglio prendere il nostro esempio da $XDG_CURRENT_DESKTOPquando viene definita questa variabile. In caso contrario, $XDG_DATA_DIRSpuò fornire le informazioni desiderate, più della prima lettera di ${DESKTOP_SESSION:0:1}.

Funziona su Ubuntu 18.10 (cosmico) [tipo lxqt] e Mint 19 (tara) [tipo cannella]:

$  set | grep XDG_CURRENT_DESKTOP | tr '[:upper:]' '[:lower:]' | cut -d'=' -f2

Cattura il risultato in una variabile ed esegui ulteriore codice necessario attraverso una logica analitica capace (case stmt, if / then) che include qualsiasi / tutti i tipi riconosciuti da lì; e / o funzionano con grazia quando sono in uso tipi non riconosciuti.