Wie richte ich tmux so ein, dass es mit bestimmten geöffneten Fenstern startet?

Sie können ein kleines Shell-Skript schreiben, das tmux mit den erforderlichen Programmen startet. Ich habe Folgendes in einem Shell-Skript, das ich dev-tmux nenne. Eine Entwicklungsumgebung:

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

Jedes Mal, wenn ich meine Lieblingsentwicklungsumgebung starten möchte, kann ich dies einfach tun

$ dev-tmux

Ich habe versucht, ein komplexes Fensterraster zu erstellen, und musste mich immer wieder mit dem Wechseln und Teilen von Fenstern befassen. Hier sind meine Erkenntnisse:

tmux new-session \;

Hiermit können Sie mit einer neuen Sitzung beginnen. Um es horizontal oder vertikal zu teilen, verwenden Sie split-window -hoder -vanschließend wie folgt:

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

Erstellt 3 Fenster wie folgt:

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

Um Befehle in diesen Bereichen auszuführen, fügen Sie sie einfach mit dem send-keys 'my-command'Befehl hinzu und der Befehl C-mführt ihn aus:

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

Und die resultierende Sitzung sollte so aussehen.

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

Jetzt habe ich versucht, den unteren linken Bereich erneut zu unterteilen, sodass ich entweder mit last-paneoder in komplexeren Fenstern zurückschalte , select-pane -t 1wobei 1die Nummer des Bereichs in der Reihenfolge beginnt, in der er erstellt wurde 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 \;

Tut das. Grundsätzlich kennen Sie sich aus split-windowund select-panesind alles, was Sie brauchen. Es ist auch praktisch, mit -p 75einer prozentualen Größe des Fensters zu übergeben, das erstellt wurde split-window, um mehr Kontrolle über die Größe der Fenster zu haben.

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 \;

Was dazu führt, dass eine Sitzung so aussieht

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

Hoffe das hilft tmuxEnthusiasten in der Zukunft.

Sie können verschiedene Sitzungen von Ihrem .tmux.confLike so beschaffen:

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

Formatieren Sie dann die Sitzungen nach Bedarf:

#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

Dies würde 2 Fenster öffnen, von denen das zweite foo / bar heißt und vertikal in zwei Hälften geteilt wird (50%), wobei foo über bar läuft. Der Fokus liegt in Fenster 2 (foo / bar), oberer Bereich (foo).

Sie können dann Ihre bevorzugte tmux-Sitzung (in diesem Fall session1) mit starten PrefixShifts

Verwenden Sie tmuxinator - Sie können mehrere Sitzungen konfigurieren und auswählen, welche zu einem bestimmten Zeitpunkt gestartet werden soll. Sie können Befehle in bestimmten Fenstern oder Fenstern starten und Windows Titel zuweisen. Hier ist ein Beispiel für die Entwicklung von Django-Anwendungen .

Beispielkonfigurationsdatei:

# ~/.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

Eine vollständige Erklärung finden Sie in der README-Datei unter dem obigen Link.

Schauen Sie unter https://github.com/remiprev/teamocil nach

Sie können Ihre Struktur mit YAML angeben

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

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

Session 1

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

Erstellen Sie einen Alias ​​in .bashrc

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

Zuerst hatte ich den Ansatz von @jasonwryan, aber wenn Sie mehr als 2 Konfigurationen haben, kann es verwirrend werden.

Also habe ich eine Alias-Funktion erstellt:

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

In habe ~/.tmux/ich mehrere Sitzungen für viele Zwecke. Zum Beispiel arbeite ich für verschiedene Unternehmen, die jeweils eine andere Entwicklungsumgebung haben. Mit der obigen Alias-Funktion kann ich einfach aufrufen: tmx company1und die Konfiguration laden, die ich brauche.

Update: Der Zweck von "$ 2" nach dem tmuxBefehl besteht darin, dass Sie zusätzliche tmux-Argumente übergeben können.

Aus meinem "get.all" -Skript, das ich jeden Morgen aufrufe, um eine Reihe nachfolgender "get.XXX" -Jobs auszuführen und die von mir verfolgte Software zu aktualisieren. Einige von ihnen werden automatisch beendet. Andere erfordern mehr Interaktion, sobald der Vorgang abgeschlossen ist (z. B. die Aufforderung, Emacs zu erstellen).

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

Wenn Sie den Bildschirm nur auf zwei Bereiche (z. B. horizontal) aufteilen möchten, können Sie diesen Befehl ausführen (keine tmux- oder Shell-Skripte erforderlich):

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

Ihr Bildschirm sieht folgendermaßen aus:

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

Und so mache ich es:

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

Ich habe eine Datei für jedes meiner Projekte. Sie können sie auch gruppieren, um einige für die Arbeit zu haben, einige für Hobbyprojekte.

Sie können es auch in einen ~/binOrdner verschieben, hinzufügen PATHund einen tmux_my_awesome_projectNamen geben . Dann können Sie es von jedem Ort aus ausführen.

Das funktioniert bei mir. Erstellen von 5 Fenstern mit den angegebenen Namen und automatische Auswahl des homeFensters.

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

Versuchen Sie es mit Bruder , es ist ein Projekt-Bootstrapper.

Es bietet einfache APIs zur Interaktion tmux .

Es sieht ungefähr so ​​aus:

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

Um ein Projekt zu starten, müssen Sie nur den folgenden Befehl ausführen:

bro start <project_name>

Im folgenden Screencast erfahren Sie, wie Sie mit broder tmuxAPI beginnen und sie verwenden .

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

Dafür gibt es ein tmux-Plugin.

Schauen Sie sich tmux-resurrect an

Stellen Sie die tmux-Umgebung nach dem Neustart des Systems wieder her.

Tmux ist großartig, außer wenn Sie den Computer neu starten müssen. Sie verlieren alle laufenden Programme, Arbeitsverzeichnisse, Fensterlayouts usw. Es gibt hilfreiche Verwaltungstools, die jedoch eine Erstkonfiguration und kontinuierliche Aktualisierungen erfordern, wenn sich Ihr Workflow weiterentwickelt oder Sie neue Projekte starten.

tmux-resurrect speichert alle kleinen Details aus Ihrer tmux-Umgebung, sodass sie nach einem Neustart des Systems (oder wenn Sie Lust dazu haben) vollständig wiederhergestellt werden können. Es ist keine Konfiguration erforderlich. Sie sollten das Gefühl haben, dass Sie tmux nie verlassen.

Oder tmux-Kontinuum

Eigenschaften:

• Kontinuierliches Speichern der tmux-Umgebung
• automatischer tmux-Start beim Einschalten von Computer / Server
• automatische Wiederherstellung beim Start von tmux

Sie sollten es in Ihrer tmux-Konfigurationsdatei ( ~/.tmux.conf) angeben , zum Beispiel:

new mocp
neww mutt

new -d
neww
neww

(Öffnet eine Sitzung mit 2 Fenstern, wobei mocp als erstes und mutt als zweites gestartet wird, und eine weitere getrennte Sitzung mit 3 leeren Fenstern).

Ich habe dieses Skript erstellt . Es braucht keinen Tmuxinator, Rubin oder andere. Es ist nur ein Bash-Skript, konfigurierbar:

Eine Datei mit dem Namen config sollte ungefähr Folgendes enthalten:

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

und der Bash-Code sollte sein:

#!/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 unterstützt die Konfiguration von JSON- oder YAML-Sitzungen und eine Python-API. Eine einfache tmuxp-Konfigurationsdatei zum Erstellen einer neuen Sitzung in YAML-Syntax lautet:

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

Das Plugin tmux-continuum speichert Ihre tmux-Sitzung automatisch und lädt sie beim nächsten Start von tmux. Es sollte einfacher einzurichten sein als einige der hier verwendeten benutzerdefinierten Skriptlösungen.

Eigenschaften:

• Kontinuierliches Speichern der tmux-Umgebung
• automatischer tmux-Start beim Einschalten von Computer / Server
• automatische Wiederherstellung beim Start von tmux

Um Ihre Sitzung bei Bedarf zu speichern, können Sie das Plugin tmux-resurrect verwenden . tmux-resurrect ist auch erforderlich, um tmux-continuum auszuführen

tmux-resurrect speichert alle kleinen Details aus Ihrer tmux-Umgebung, sodass sie nach einem Neustart des Systems (oder wenn Sie Lust dazu haben) vollständig wiederhergestellt werden können. Es ist keine Konfiguration erforderlich. Sie sollten das Gefühl haben, dass Sie tmux nie verlassen.

Sie können tmux-Hooks verwenden , um Befehle auszuführen, wenn eine neue Sitzung erstellt wird. Insbesondere wird dies mit dem erreichtsession-created Haken erreicht.

Um den Bildschirm beispielsweise auf drei Arten zu teilen, während htop unten rechts ausgeführt wird, können Sie Ihrer ~/.tmux.confDatei die folgende Zeile hinzufügen :

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

Der Vorteil dieser Methode ist, dass Sie tmux nicht auf spezielle Weise ausführen müssen (z. B. Shell-Skript oder Alias), um das gewünschte Ergebnis zu erzielen. Sie können dies auch mit tmux new-session -A -s mysessionder in dieser anderen Antwort beschriebenen kombinieren sodass die Hook-Befehle nur ausgeführt werden, wenn Sie die Sitzung zum ersten Mal erstellen, und nicht bei nachfolgenden Anhängen.

Diese Funktion wurde 2016 von d15d54c2c hinzugefügt . Die erste Version, die sie enthält, ist 2.4.

Ich habe gerade versucht, alle Ideen auf dieser Seite zu verwenden, und ich mochte keine davon. Ich wollte nur eine Lösung, die tmux mit einem bestimmten Satz von Fenstern startete, als mein Terminal geöffnet wurde. Ich wollte auch, dass es idempotent ist, dh das Öffnen eines neuen Terminalfensters übernimmt die tmux-Sitzung von der vorherigen.

Die oben genannten Lösungen öffnen häufig mehrere tmux-Sitzungen, und ich möchte nur eine. Zuerst habe ich dies zu meinem hinzugefügt ~/.bash_profile:

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

dann habe ich folgendes zu meinem hinzugefügt ~/.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

Jedes Mal, wenn ich ein Terminal starte oder tmux oder was auch immer starte, verbinde ich mich entweder wieder mit meinem vorhandenen gewünschten Setup (der benannten Sitzung default) oder erstelle eine neue Sitzung mit diesem Setup.

Dieses Skript startet eine Sitzung mit dem Namen "e" und drei Fenstern

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