Jak skonfigurować Tmux, aby uruchamiał się z określonymi oknami otwartymi?

Możesz napisać mały skrypt powłoki, który uruchamia tmux z wymaganymi programami. W skrypcie powłoki mam następujące polecenie dev-tmux. Środowisko deweloperskie:

#!/bin/sh
tmux new-session -d 'vim'
tmux split-window -v 'ipython'
tmux split-window -h
tmux new-window 'mutt'
tmux -2 attach-session -d

Więc za każdym razem, gdy chcę uruchomić moje ulubione środowisko programistyczne, mogę to zrobić

$ dev-tmux

Próbowałem stworzyć złożoną siatkę paneli i musiałem ciągle radzić sobie z przełączaniem i dzieleniem paneli. Oto moje wnioski:

tmux new-session \;

Pobiera rozpoczęcie nowej sesji. Aby podzielić go na poziomy lub pionowy, użyj go split-window -hlub -vpóźniej:

tmux new-session \; split-window -v \; split-window -h \;

Tworzy 3 panele, takie jak to:

------------
|          |
|----------|
|    |     |
------------

Aby uruchomić polecenia w tych panelach, po prostu dodaj je za pomocą send-keys 'my-command'polecenia i, C-mktóre je wykonuje:

tmux new-session \; \
  send-keys 'tail -f /var/log/monitor.log' C-m \; \
  split-window -v \; \
  split-window -h \; \
  send-keys 'top' C-m \; 

Wynikowa sesja powinna tak wyglądać.

------------
|  tail    |
|----------|
|    | top |
------------

Teraz próbowałem ponownie podzielić lewy dolny panel, więc przełączam się z powrotem za pomocą last-panelub w bardziej złożonych oknach, select-pane -t 1gdzie gdzie 1jest numer panelu w kolejności utworzonej od 0.

tmux new-session \; \
  send-keys 'tail -f /var/log/monitor.log' C-m \; \
  split-window -v \; \
  split-window -h \; \
  send-keys 'top' C-m \; \
  select-pane -t 1 \; \
  split-window -v \; \
  send-keys 'weechat' C-m \;

Robi to. Zasadniczo wiesz, jak sobie radzić split-windowi select-panewszystko, czego potrzebujesz. Przydatne jest również podanie z -p 75procentowym rozmiarem panelu utworzonego przez, split-windowaby mieć większą kontrolę nad rozmiarem paneli.

tmux new-session \; \
  send-keys 'tail -f /var/log/monitor.log' C-m \; \
  split-window -v -p 75 \; \
  split-window -h -p 30 \; \
  send-keys 'top' C-m \; \
  select-pane -t 1 \; \
  split-window -v \; \
  send-keys 'weechat' C-m \;

W rezultacie sesja wygląda tak

------------------
|      tail      |
|----------------|
|          | top |
|----------|     |
| weechat  |     |
------------------

Mam nadzieję, że pomoże tmuxentuzjastom w przyszłości.

Możesz pozyskiwać różne sesje od swoich .tmux.confpodobnych:

# initialize sessions
bind S source-file ~/.tmux/session1 
bind s source-file ~/.tmux/session2

A następnie sformatuj sesje według potrzeb:

#session1
new  -s SessionName -n WindowName Command
neww -n foo/bar foo
splitw -v -p 50 -t 0 bar
selectw -t 1 
selectp -t 0

Otworzyłyby się 2 okna, z których drugie nazwano by foo / bar i byłoby podzielone pionowo na pół (50%) z foo działającym powyżej paska. Fokus byłby w oknie 2 (foo / bar), w górnym okienku (foo).

Następnie możesz rozpocząć preferowaną sesję tmux (w tym przypadku sesję 1) za pomocą PrefixShifts

Użyj tmuxinatora - pozwala na skonfigurowanie wielu sesji i możesz wybrać, która ma zostać uruchomiona w danym momencie. Możesz uruchamiać polecenia w określonych oknach lub oknach i nadawać tytuły oknom. Oto przykład zastosowania z programowaniem aplikacji Django .

Przykładowy plik konfiguracyjny:

# ~/.tmuxinator/project_name.yml
# you can make as many tabs as you wish...

project_name: Tmuxinator
project_root: ~/code/rails_project
socket_name: foo # Not needed. Remove to use default socket
rvm: 1.9.2@rails_project
pre: sudo /etc/rc.d/mysqld start
tabs:
  - editor:
      layout: main-vertical
      panes:
        - vim
        - #empty, will just run plain bash
        - top
  - shell: git pull
  - database: rails db
  - server: rails s
  - logs: tail -f logs/development.log
  - console: rails c
  - capistrano:
  - server: ssh me@myhost

Pełne wyjaśnienie znajduje się w pliku README pod powyższym linkiem.

spójrz @ https://github.com/remiprev/teamocil

możesz określić swoją strukturę za pomocą YAML

windows:
  - name: sample-window
    splits:
      - cmd: vim
      - cmd:
        - ipython
        width: 50
      - cmd:
        height: 25

:~$ tmux new-session "tmux source-file ~/session1"  

sesja 1

neww
split-window -v 'ipython'  
split-window -h  
new-window 'mutt'  

utwórz alias w .bashrc

:~$ echo `alias tmux_s1='tmux new-session "tmux source-file ~/session1"'` >>~/.bashrc  
:~$ . ~/.bashrc  
:~$ tmux_s1  

Najpierw miałem podejście z @jasonwryan ale jeśli masz więcej niż 2 konfiguracje, może to być mylące.

Więc stworzyłem funkcję aliasu:

tmx () {
    tmux "$2" source-file "$HOME/.tmux/$1.conf";
}

W ~/.tmux/mam wiele sesji dla wielu zastosowań. Na przykład pracuję dla różnych firm, które mają środowisko deweloperów. Tak więc z powyższą funkcją aliasu mogę po prostu wywołać: tmx company1i załadować potrzebną konfigurację.

Aktualizacja: Celem polecenia „2 $” po tmuxpoleceniu jest przekazanie dodatkowych argumentów tmux.

Ze skryptu „get.all”, który wywołuję każdego ranka, aby uruchomić kilka kolejnych zadań „get.XXX” w celu odświeżenia oprogramowania, które śledzę. Niektóre z nich są automatycznie zamykane. Inne wymagają więcej interakcji po zakończeniu pobierania (np. Prośba o zbudowanie emacsa).

#!/bin/sh
tmux att -t get ||
tmux \
  new -s get -n capp \; \
  send-keys 'get.capp' C-m \; \
  neww -n emacs \; \
  send-keys 'get.emacs' C-m \; \
  neww -n git \; \
  send-keys 'get.git' C-m \; \
  neww -n mini \; \
  send-keys 'get.mini' C-m \; \
  neww -n port \; \
  send-keys 'get.port' C-m \; \
  neww -n rakudo \; \
  send-keys 'get.rakudo' C-m \; \
  neww -n neil \; \
  send-keys 'get.neil && get.neil2 && exit' C-m \; \
  neww -n red \; \
  send-keys 'get.red && exit' C-m \; \
  neww -n cpan \; \
  send-keys 'get.cpan && exit' C-m \; \
  selectw -t emacs

Jeśli chcesz po prostu podzielić ekran na 2 panele (powiedzmy poziomo), możesz uruchomić to polecenie (nie są wymagane skrypty tmux ani powłoki):

tmux new-session \; split-window -h \;

Twój ekran będzie wyglądał następująco:

[ks@localhost ~]$                      │[ks@localhost ~]$ 
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
                                       │
[10] 0:ks@localhost:~*                  "localhost.localdomain" 19:51 31-янв-16

I tak to robię:

#!/bin/bash

function has-session {
  tmux has-session -t name_of_my_session 2>/dev/null
}

if has-session ; then
  echo "Session already exists"
else
  cd /path/to/my/project
  tmux new-session -d -s name_of_my_session 'vim'
  tmux split-window -h -p 40 start_web_server
  tmux split-window -v
  tmux attach-session -d -t name_of_my_session
fi

Mam jeden plik dla każdego mojego projektu. Możesz także pogrupować je, aby mieć trochę do pracy dla projektów hobbystycznych.

Możesz także przenieść go do ~/binfolderu, dodać go PATHi podać tmux_my_awesome_projectnazwę. Będziesz mógł uruchomić go z każdego miejsca.

To działa dla mnie. Tworzenie 5 okien o podanych nazwach i automatyczne wybieranie do homeokna.

new  -n home
neww -n emacs
neww -n puppet
neww -n haskell
neww -n ruby
selectw -t 1

Spróbuj, stary , to bootstrapper projektu.

Zapewnia łatwą interakcję z apis tmux .

Wygląda to mniej więcej tak:

#!/bin/sh
# @ project_name/tasks/init.sh
structure project_name
  window editor
    run 'vim'
  window terminal
    run 'echo happy coding ...'
focus editor
connect project_name

Aby uruchomić projekt, wystarczy uruchomić polecenie:

bro start <project_name>

Obejrzyj zrzut ekranu poniżej, który pokazuje, jak zacząć brokorzystać z tmuxinterfejsu API.

https://user-images.githubusercontent.com/8296449/50532502-2cf3e400-0b6e-11e9-84af-c5f77a04e5cc.gif

Jest do tego wtyczka tmux.

Sprawdź tmux-resurrect

Przywróć środowisko tmux po restarcie systemu.

Tmux jest świetny, z wyjątkiem sytuacji, gdy musisz ponownie uruchomić komputer. Tracisz wszystkie działające programy, działające katalogi, układy okien itp. Istnieją przydatne narzędzia do zarządzania, ale wymagają one wstępnej konfiguracji i ciągłych aktualizacji w miarę ewolucji przepływu pracy lub rozpoczynania nowych projektów.

tmux-resurrect zapisuje wszystkie małe szczegóły ze środowiska tmux, dzięki czemu można je całkowicie przywrócić po ponownym uruchomieniu systemu (lub gdy masz na to ochotę). Nie jest wymagana konfiguracja. Powinieneś czuć, że nigdy nie rezygnujesz z Tmux.

Lub tmux-continuum

Cechy:

• ciągłe oszczędzanie środowiska tmux
• automatyczny start tmux po włączeniu komputera / serwera
• automatyczne przywracanie po uruchomieniu tmux

Powinieneś to określić w pliku konfiguracyjnym tmux ( ~/.tmux.conf), na przykład:

new mocp
neww mutt

new -d
neww
neww

(otwiera jedną sesję z 2 oknami z uruchomionym mocpem w pierwszej i mutt w drugiej, a drugą odłączoną sesją z 3 pustymi oknami).

Stworzyłem ten skrypt . Nie potrzebuje tmuxinatora, rubinu ani innych. To tylko skrypt bash, konfigurowalny:

Plik o nazwie config powinien zawierać coś takiego:

combo=()
combo+=('logs' 'cd /var/log; clear; pwd')
combo+=('home' 'cd ~; clear; pwd')

a kod bash powinien być:

#!/bin/bash

if [ -r config ]; then
    echo ""
    echo "Loading custom file"
    . config
else
    . config.dist
fi

tmux start-server

window=0
windownumber=-1

for i in "${combo[@]}"; do

    if [ $((window%2)) == 0 ]; then
        name=${i}
        ((windownumber++))
    else
        command=${i}
    fi

    if [ ${combo[0]} == "${i}" ]; then
        tmux new-session -d -s StarTmux -n "${name}"
    else
        if [ $((window%2)) == 0 ]; then
            tmux new-window -tStarTmux:$windownumber -n "${name}"
        fi
    fi

    if [ $((window%2)) == 1 ]; then
        tmux send-keys -tStarTmux:$windownumber "${command}" C-m
    fi

    ((window++))
done

tmux select-window -tStarTmux:0
tmux attach-session -d -tStarTmux

tmuxp obsługuje konfigurację sesji JSON lub YAML oraz API Pythona. Prosty plik konfiguracyjny tmuxp do utworzenia nowej sesji w składni YAML to:

session_name: 2-pane-vertical
windows:
  - window_name: my test window
    panes:
      - pwd
      - pwd

Wtyczka tmux-continuum automatycznie zapisze twoją sesję tmux i załaduje ją przy następnym uruchomieniu tmux, powinna być łatwiejsza do skonfigurowania niż niektóre niestandardowe rozwiązania skryptowe tutaj.

Cechy:

• ciągłe oszczędzanie środowiska tmux
• automatyczny start tmux po włączeniu komputera / serwera
• automatyczne przywracanie po uruchomieniu tmux

Aby zapisać swoją sesję na żądanie, możesz użyć wtyczki Tmux-Resurrect . tmux-resurrect jest również wymagany do uruchomienia tmux-continuum

tmux-resurrect zapisuje wszystkie małe szczegóły ze środowiska tmux, dzięki czemu można je całkowicie przywrócić po ponownym uruchomieniu systemu (lub gdy masz na to ochotę). Nie jest wymagana konfiguracja. Powinieneś czuć, że nigdy nie rezygnujesz z Tmux.

Możesz użyć haczyków tmux do wykonywania poleceń podczas tworzenia nowej sesji. W szczególności osiąga się to za pomocą session-createdhaka.

Na przykład, aby podzielić ekran na trzy sposoby z uruchomionym htopem w prawym dolnym rogu, możesz dodać następujący wiersz do ~/.tmux.confpliku:

set-hook -g session-created 'split -h ; split -v top'

Zaletą tej metody jest to, że nie trzeba uruchamiać tmux w żaden specjalny sposób (tj. Skrypt powłoki lub alias), aby uzyskać pożądany wynik. Możesz to również połączyć z tmux new-session -A -s mysessionopisem w innej odpowiedzi tak aby polecenia przechwytujące były uruchamiane tylko podczas pierwszego tworzenia sesji, a nie przy kolejnych załącznikach.

Ta funkcja została dodana przez d15d54c2c w 2016 roku. Pierwsza dostępna wersja to 2.4.

Właśnie próbowałem użyć wszystkich pomysłów z tej strony i nie podobało mi się żadne z nich. Chciałem tylko rozwiązania, które uruchomiło tmux z określonym zestawem okien, kiedy mój terminal się otworzył. Chciałem też, aby był idempotentny, tzn. Otwarcie nowego okna terminala przejmuje sesję tmux od poprzedniej.

Powyższe rozwiązania często otwierają wiele sesji tmux i chcę tylko jedną. Najpierw dodałem to do mojego ~/.bash_profile:

tmux start-server
if [[ -z "$TMUX" ]]
then
  exec tmux attach -d -t default
fi

następnie dodałem do mojego ~/.tmux.conf:

new -s default -n emacs /usr/local/bin/emacs
neww -n shell /usr/local/bin/bash
neww -n shell /usr/local/bin/bash
selectw -t 1

teraz za każdym razem, gdy uruchamiam terminal, uruchamiam tmux lub cokolwiek, albo ponownie przyłączam się do mojej istniejącej konfiguracji (nazwa sesji default), albo tworzę nową sesję z tą konfiguracją.

Ten skrypt rozpoczyna sesję o nazwie „e” i trzech oknach

#!/bin/sh 
tmux new-session -s e   -n etc -d 'cd /etc; bash -i'
tmux new-window  -t e:1 -n home   'cd ~; bash -i'
tmux new-window  -t e:2 -n log   'cd /var/log; bash -i'

tmux select-window -t e:1
tmux -2 attach-session -t e