Czy terminalowy multiplekser ma jakąkolwiek korzyść, gdy jest używany z menedżerem okien kafelkowych?

Zarówno terminalowe multipleksery (ekran, tmux), jak i obsługiwane przez klawiaturę menedżery okien kafelkowych (ratpoison, dwm, xmonad) zapewniają podobną funkcjonalność. Czy korzystanie z obu jednocześnie jest korzystne? Co z problemami, które mogą się pojawić?

Używam dwm i tmux. Zanim nauczę się korzystać z tmux, chciałbym mieć wiele terminali otwartych dla różnych rzeczy i mieć je w różnych znacznikach. Teraz mogę uruchomić wszystko w jednej sesji tmux, pod jednym tagiem, i mogę się odłączyć i ponownie podłączyć bez utraty stanu, jeśli będę musiał ponownie uruchomić X.

Dodatkową zaletą multiplekserów terminalowych jest to, że sesje multipleksera będą nadal żywe i możesz się z nimi ponownie połączyć, nawet jeśli X (sesja pulpitu) ulegnie awarii lub wylogujesz się z X.

Użyj obu: menedżera okien kafelkowych i multipleksera terminali.

Połącz ich możliwości i zalety, aby uzyskać jeszcze lepszą synergię. W mojej konfiguracji i3 regularnie wyświetlam kilka terminali w tym samym czasie, ale wszystkie są podłączone do tej samej sesji tmux , więc mogę wyświetlić wszystkie okna tmux w dowolnym z terminali .

W efekcie korzystam z możliwości kafelkowania, i3aby zastąpić / rozszerzyć funkcjonalność dzielenia / przenoszenia okien multipleksera terminali, aby (imho) uzyskać to, co najlepsze z obu światów.

Poniższy skrypt służy do zarządzania połączeniem sesji / wykrywania i czyszczenia po uruchomieniu terminala:

#!/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

Nie. W tych rzadkich przypadkach, gdy przydatny jest screen wewnątrz ekranu lub tmux wewnątrz tmux, oba programy zapewniają prosty sposób przekazania kontroli do zagnieżdżonej instancji.

Screen oferuje możliwości konsoli szeregowej, ale w razie potrzeby używam dedykowanej aplikacji (miniterm.py rozpowszechnianej z pythonem). W przeciwnym razie nie mogę wymyślić niczego od razu, co jedno może zrobić, a drugie nie, ale jeden może to zrobić prościej niż drugi.

Nauczę się jednego lub drugiego, a jeśli jesteś ciekawy lub niezadowolony z tego, co wybrałeś, spróbuj drugiego. Osobiście wolę tmux.

Innym przydatnym aspektem multipleksera terminali w tym scenariuszu jest połączenie się ze zdalnymi serwerami. Typowy przypadek użycia, jaki znalazłem, to

1. Otwórz okno terminala na moim komputerze lokalnym.
2. ssh do zdalnego serwera.
3. tmux / screen zapewnia teraz multipleksowanie na zdalnym serwerze, umożliwiając łatwe otwieranie nowych terminali / powłok na zdalnym serwerze. W porównaniu z otwarciem drugiego terminala na komputerze lokalnym i ponownym połączeniem z drugim ssh, jest to o jeden krok mniej.