Como eu crio um conf tmux simples que divide uma janela?

Question

Eu gostaria de criar um conf tmux simples que faça o seguinte.

1. Divide a janela / painel / whatever_stupid_terminology horizontalmente (hsplit)
2. Abre no painel superior tail -f foo
3. Abre no painel inferior tail -f bar

Como posso fazer isso com o tmux?

Isso é o que eu tenho,

#!/bin/sh
tmux new-session -s asdf -n myWindow
tmux select-window -t myWindow
tmux split-window "tail -f /var/log/apache2/samperror.log" 
tmux attach-session -t asdf

Não consigo fazer nada funcionar. Então eu sei que está tudo errado. Um dos arquivos conf pouco mais intuitivos de todos os tempos

    

Answer 1

Aqui está uma linha de comando rápida e suja que atinge o que você quer:

$ tmux new-session -s asdf -n myWindow -d 'tail -f foo'\; \
       split-window -d 'tail -f bar'\; attach-session

Existem algumas desvantagens para esta solução:

• não escala muito bem (mais alguns comandos e o resultado é incompreensível).

• os dois comandos tail não são executados em um shell interativo; portanto, se você sair dos dois, a janela myWindow será destruída (junto com a sessão, se você não tiver criado mais sessões.

Aqui está um script de shell que funciona nas linhas que você tentou. Para mim, é sempre mais fácil pensar em como eu alcançaria meu objetivo manualmente e depois traduzir isso em comandos do tmux. Essa pode não ser a maneira mais simples ou mais limpa, mas geralmente funciona:

#!/bin/sh
# create a new session. Note the -d flag, we do not want to attach just yet!
tmux new-session -s asdf -n 'myWindow' -d

# send 'tail -f foo<enter>' to the first pane.
# I address the first pane using the -t flag. This is not necessary,
# I'm doing it so explicitly to show you how to do it.
# for the <enter> key, we can use either C-m (linefeed) or C-j (newline)
tmux send-keys -t asdf:myWindow.0 'tail -f foo' C-j

# split the window *vertically*
tmux split-window -v

# we now have two panes in myWindow: pane 0 is above pane 1
# again, specifying pane 1 with '-t 1' is optional
tmux send-keys -t 1 'tail -f bar' C-j

# uncomment the following command if you want to attach
# explicitly to the window we just created

#tmux select-window -t asdf:mywindow

# finally attach to the session
tmux attach -t asdf

Se, após algumas tentativas, você ainda não gostar da sintaxe de comando e configuração tmux , convém consultar o tmuxinator , uma jóia Ruby que permite gerenciar sessões tmux com uma sintaxe simplificada e transparente.

Em minha resposta a Múltiplos terminais de uma só vez sem um servidor X , você pode encontrar alguns links úteis para tmux de recursos

    

Answer 2

Com base na resposta , aqui está um código mais genérico:

tmuxMany(){
    #https://unix.stackexchange.com/a/149729/47116
    if [ $# -lt 2 ]; then
        echo usage: sessionName command1 command2 ...
        return 1
    fi
    local sessionName=$1
    local firstCommand=$2
    local secondAndRestCommands=( "${@:3}" )

    tmux new-session -s $sessionName -n 'myWindow' -d
    tmux send-keys -t $sessionName:myWindow.0 "$firstCommand" C-j
    local i
    for i in "${!secondAndRestCommands[@]}"
    do
        echo $i
        local command=${secondAndRestCommands[$i]}
        echo $command

        tmux split-window -v
        local tabNumber=$((i+1))
        tmux send-keys -t $tabNumber "$command" C-j
    done
    tmux select-layout even-vertical
    tmux attach -t $sessionName
}

Uso:

tmuxMany sessionName "tail -f file" "tail -f file2" htop

Será aberto o tmux com 3 painéis de altura igual.

    

Answer 3

Supondo que você queira executar isso de seu ~/.tmux.conf , não de um script externo, adicione isso ao seu arquivo de configuração:

# session initialisation
new -s SessionName -n WindowName 'tail -f /var/log/apache2/samperror.log'
splitw -h -p 50 -t 0 'tail -f /var/log/apache2/other.log'
selectw -t 0

Então, quando você iniciar o tmux com o comando para anexar a uma sessão, tmux a , ele criará SessionName com a janela dividida horizontalmente ( -h ) na metade ( -p 50 ) executando esses dois comandos.

    

Answer 4

É assim que eu lanço um editor + REPL agora:

mux $(basename $(pwd)) \
  "vim $(find src test resources test-resources -type f 2>/dev/null \
    | tr "\n" " ")" \
  "lein repl"

Invadi o código Maxim para obter um layout diferente:

#!/bin/bash

#https://unix.stackexchange.com/a/149729/47116
if [ $# -lt 2 ]; then
    echo usage: sessionName command1 command2 ...
    return 1
fi
sessionName=$1
firstCommand=$2
secondAndRestCommands=( "${@:3}" )

tmux new-session -s $sessionName -n 'myWindow' -d
WIN="$sessionName:myWindow"
tmux send-keys -t $WIN.1 "$firstCommand" C-j
for i in "${!secondAndRestCommands[@]}"
do
    command=${secondAndRestCommands[$i]}
    echo $i: $command

    tmux split-window -v
    tabNumber=$((i+2))
    tmux send-keys -t $tabNumber "$command" C-j
done
tmux select-pane -t $WIN.1

fixlayout() {
    tmux set-window-option -t $WIN main-pane-width $(($COLUMNS - 80))
    tmux select-layout -t $WIN main-vertical
}
fixlayout
sleep 1 && fixlayout &

tmux attach -t $sessionName

Por acaso, o tmux.conf parece bastante útil.

    

Answer 5

Tente algo assim:

$ chmod +x tmux.conf
$ cat tmux.conf
#!/usr/bin/tmux source-file
new-session -s asdf -n myWindow "tail -f /var/log/maillog"
split-window "tail -f /var/log/messages"

Quando você executa ./tmux.conf , o tmux executa cada comando, criando o layout solicitado.

A parte surpreendente é que tmux -f tmux.conf apenas executa os comandos em tmux.conf para a primeira sessão criada. Se você já tem sessões em execução, o -f tmux.conf é silenciosamente ignorado. Você pode contornar isso com tmux source-file tmux.conf . Você pode usar isso em uma linha shebang, para torná-lo um script.

Eu achei essa técnica realmente útil. Na raiz de cada um dos diretórios do meu projeto, eu tenho um executável tmux.conf . Quando começo a trabalhar no projeto novamente, corro ./tmux.conf para criar o ambiente de trabalho que prefiro para esse projeto.