Un multiplexeur de terminal présente-t-il un avantage lorsqu'il est utilisé avec un gestionnaire de fenêtres de mosaïque?

Les multiplexeurs de terminaux (écran, tmux) et les gestionnaires de fenêtres de mosaïque pilotés par clavier (ratpoison, dwm, xmonad) offrent des fonctionnalités similaires. Y a-t-il un avantage à utiliser les deux en même temps? Qu'en est-il des problèmes qui peuvent survenir?

J'utilise dwm et tmux. Avant d'apprendre à utiliser tmux, j'aurais plusieurs terminaux ouverts pour différentes choses et les aurais dans différentes balises. Maintenant, je peux tout exécuter à l'intérieur d'une session tmux, sous une seule balise, et je peux détacher et rattacher sans perdre d'état si j'ai besoin de redémarrer X.

L'avantage supplémentaire des multiplexeurs de terminaux est que vos sessions de multiplexeur seront toujours actives et que vous pourrez vous reconnecter à celles-ci même si X (votre session de bureau) se bloque ou si vous vous déconnectez de X.

Utilisez à la fois: un gestionnaire de fenêtres en mosaïque et un multiplexeur de terminaux.

Combinez à la fois leurs capacités et leurs avantages pour obtenir une synergie encore meilleure. Sur ma configuration i3, j'affiche régulièrement plusieurs terminaux en même temps, mais tous sont connectés à la même session tmux , donc je peux afficher toutes les fenêtres tmux dans n'importe lequel des terminaux .

En effet, j'utilise les capacités de tuilage de i3pour remplacer / augmenter la fonctionnalité de division / déplacement de fenêtre du multiplexeur de terminal pour (à mon humble avis) tirer le meilleur parti des deux mondes.

Le script ci-dessous est utilisé ici pour gérer la connexion de session / détection et le nettoyage au démarrage du terminal:

#!/bin/bash
# This script attaches the terminal to a common session, where all
# terminals can show any window of the main tmux session independently
# This script also cleans up "old" sessions
# Todo: Cosmetic fix-ups. Make less verbose.

DEBUG="y"
showRun(){ echo Will run: $@;test -z $DEBUG||read -n1 -p"Press ENTER";$@; }

SNAME=${1:-XyZ}

if ! tmux has -t $SNAME; then
    echo -n "Session $SNAME not found, creating it: "
    showRun exec tmux new-session -s $SNAME;
else
    echo -n "Session $SNAME found: "
    MySESSION=$(tmux ls | grep -E "^$SNAME:.*\(attached\)$")
    echo $MySESSION;
    if [ -z "$MySESSION" ] ; then
        echo "Session $SNAME unattached, seizing it:"
        showRun exec tmux attach -t $SNAME \; new-window
    else
        echo "Session $SNAME already attached, finding grouped Sessions:"
        REGEX="group ([^)]*)"
        [[ $MySESSION =~ $REGEX ]]
        GNAME=${BASH_REMATCH[1]}
        GSESSIONS=$(tmux ls | grep "group $GNAME)" | grep -v $SNAME:)
        echo "$GSESSIONS"
        if [ -z "$GSESSIONS" ]; then
            echo "No sessions in group with $SNAME found, creating new one:"
            showRun exec tmux new-session -t $SNAME \; new-window
        else
            FGSESSIONS=$(echo "$GSESSIONS" | grep -v attached )
            if [ -z "$FGSESSIONS" ]; then
                echo "No free sessions in group $GNAME found, creating new one:"
                showRun exec tmux new-session -t $SNAME \; new-window
            else
                echo -e "Free grouped Sessions:\n $FGSESSIONS";
                if echo "$FGSESSIONS" | tail -n +2 | grep . > /dev/null; then
                    echo "Several detached Sessions found, cleaning up:"
                    echo "$FGSESSIONS" | while read SID x ; do
                        if [ -z $KEEPSID ]; then
                            KEEPSID=${SID%:*};
                            echo "Keeping session $KEEPSID for takeover after cleanup"
                        else
                            echo "Cleaning up old detached session $SID"
                            tmux kill-session -t ${SID%:}
                        fi;
                    done
                    KEEPSID=$(tmux ls|grep "group $GNAME)" | grep -v attached);
                    KEEPSID=${KEEPSID%: *}
                    echo "Attaching to session $KEEPSID:"
                    showRun exec tmux attach -t $KEEPSID \; new-window
                else
                    echo "Free session ( ${FGSESSIONS%: *} ) found, seizing it:"
                    showRun exec tmux attach -t ${FGSESSIONS%: *} \; new-window
                fi ;
            fi ;
        fi ;
    fi ;
fi

Non. Dans les rares cas où écran à l'intérieur de l'écran ou tmux à l'intérieur de tmux est utile, les deux programmes fournissent un moyen simple de passer le contrôle à l'instance imbriquée.

Screen offre des capacités de console série, mais j'utilise simplement une application dédiée (miniterm.py distribuée avec python) quand j'en ai besoin. Sinon, je ne peux pas penser à quoi que ce soit qui puisse faire et l'autre pas, mais l'un pourrait le faire plus simplement que l'autre.

J'apprendrais l'un ou l'autre, et si vous êtes curieux ou insatisfait de ce que vous avez choisi, essayez l'autre. Je préfère tmux, personnellement.

Un autre aspect utile d'un multiplexeur de terminal dans ce scénario est après la connexion à des serveurs distants. Un cas d'utilisation typique que je trouve est

1. Ouvrez une fenêtre de terminal sur mon PC local.
2. ssh dans un serveur distant.
3. tmux / screen fournit désormais le multiplexage sur le serveur distant, permettant l'ouverture facile de nouveaux terminaux / shells sur le serveur distant. Comparé à l'ouverture d'un deuxième terminal sur un PC local et à la reconnexion avec un deuxième ssh, c'est une étape de moins.