Comment configurer tmux pour qu'il démarre avec les fenêtres spécifiées ouvertes?

Vous pouvez écrire un petit script shell qui lance tmux avec les programmes requis. J'ai ce qui suit dans un script shell que j'appelle dev-tmux. Un environnement de développement:

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

Donc, chaque fois que je veux lancer mon environnement de développement préféré, je peux le faire

$ dev-tmux

J'essayais de créer une grille complexe de volets et j'ai dû faire face à la commutation et au fractionnement des volets encore et encore. Voici mes apprentissages:

tmux new-session \;

Vous permet de démarrer avec une nouvelle session. Pour le diviser horizontalement ou verticalement, utilisez-le split-window -hou -vpar la suite, comme ça:

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

Crée 3 volets, comme ceci:

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

Pour exécuter des commandes dans ces volets, ajoutez-les simplement avec la send-keys 'my-command'commande et C-mqui l'exécute:

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

Et la session résultante devrait ressembler à ça.

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

Maintenant, j'ai essayé de sous-diviser à nouveau le volet inférieur gauche, afin de revenir soit en utilisant last-pane, soit dans des fenêtres plus complexes, select-pane -t 1où 1est le numéro du volet dans l'ordre créé en commençant par 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 \;

Est-ce que. Fondamentalement, connaître votre chemin split-windowet select-panec'est tout ce dont vous avez besoin. Il est également pratique de passer avec -p 75un pourcentage de taille du volet créé par split-windowpour avoir plus de contrôle sur la taille des volets.

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

Ce qui donne une session ressemblant à ça

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

J'espère que cela aidera les tmuxpassionnés à l'avenir.

Vous pouvez vous procurer différentes sessions à partir de votre .tmux.confcomme:

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

Et puis formatez les sessions selon vos besoins:

#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

Cela ouvrirait 2 fenêtres, la seconde serait nommée foo / bar et serait divisée verticalement en deux (50%) avec foo au-dessus de la barre. Le focus serait dans la fenêtre 2 (foo / bar), volet supérieur (foo).

Vous pouvez ensuite démarrer votre session tmux préférée (dans ce cas, session1) avec PrefixShifts

Utilisez tmuxinator - il vous permet d'avoir plusieurs sessions configurées, et vous pouvez choisir celle à lancer à tout moment. Vous pouvez lancer des commandes dans des fenêtres ou des volets particuliers et donner des titres aux fenêtres. Voici un exemple d'utilisation avec le développement d'applications Django .

Exemple de fichier de configuration:

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

Voir le fichier README sur le lien ci-dessus pour une explication complète.

jetez un oeil à https://github.com/remiprev/teamocil

vous pouvez spécifier votre structure en utilisant YAML

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'  

créer un alias dans .bashrc

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

J'ai d'abord eu l'approche de @jasonwryan mais si vous avez plus de 2 configurations, cela peut devenir déroutant.

J'ai donc créé une fonction d'alias:

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

Dans ~/.tmux/j'ai plusieurs sessions pour de nombreuses utilisations. Par exemple, je travaille pour différentes entreprises qui ont un environnement de développement différent. Donc, avec la fonction d'alias ci-dessus, je peux simplement appeler: tmx company1et charger la configuration dont j'ai besoin.

Mise à jour: Le but de "$ 2" après la tmuxcommande est que vous puissiez passer des arguments tmux supplémentaires.

A partir de mon script "get.all", que j'invoque chaque matin pour exécuter un tas de jobs "get.XXX" ultérieurs pour rafraîchir le logiciel que je surveille. Certains d'entre eux s'arrêtent automatiquement. D'autres nécessitent plus d'interaction une fois le get terminé (comme demander de construire emacs).

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

Si vous voulez juste diviser l'écran sur 2 volets (par exemple horizontalement), vous pouvez exécuter cette commande (aucun script tmux ou shell requis):

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

Votre écran ressemblera à ceci:

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

Et voici comment je le fais:

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

J'ai un fichier pour chacun de mes projets. Vous pouvez également les regrouper pour en avoir pour le travail, pour des projets de loisirs.

Vous pouvez également le déplacer dans un ~/bindossier, l'ajouter PATHet donner un tmux_my_awesome_projectnom. Ensuite, vous pourrez l'exécuter à partir de chaque endroit.

Cela fonctionne pour moi. Création de 5 fenêtres avec les noms donnés et sélection automatique de la homefenêtre.

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

Essayez bro , c'est un bootstrapper de projet.

Il fournit des API faciles à interagir avec tmux .

Cela ressemble à ceci:

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

Pour lancer un projet, il suffit d'exécuter la commande suivante -

bro start <project_name>

Découvrez le screencast ci-dessous, il montre comment commencer broet utiliser son tmuxapi.

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

Le plugin tmux-continuum enregistrera automatiquement votre session tmux et la chargera au prochain démarrage de tmux, devrait être plus facile à configurer que certaines des solutions de script personnalisées ici.

Fonctionnalités:

• économie continue de l'environnement tmux
• démarrage automatique de tmux lorsque l'ordinateur / serveur est allumé
• restauration automatique au démarrage de tmux

Pour enregistrer votre session à la demande, vous pouvez utiliser le plugin tmux-resurrect . tmux-resurrect est également requis pour exécuter tmux-continuum

tmux-resurrect enregistre tous les petits détails de votre environnement tmux afin qu'il puisse être complètement restauré après un redémarrage du système (ou quand vous en avez envie). Aucune configuration n'est requise. Vous devriez avoir l'impression de ne jamais quitter tmux.

Il existe un plugin tmux pour cela.

Découvrez tmux-resurrect

Restaurez l'environnement tmux après le redémarrage du système.

Tmux est génial, sauf quand vous devez redémarrer l'ordinateur. Vous perdez tous les programmes en cours d'exécution, les répertoires de travail, les dispositions de volet, etc.

tmux-resurrect enregistre tous les petits détails de votre environnement tmux afin qu'il puisse être complètement restauré après un redémarrage du système (ou quand vous en avez envie). Aucune configuration n'est requise. Vous devriez avoir l'impression de ne jamais quitter tmux.

Ou tmux-continuum

Fonctionnalités:

• économie continue de l'environnement tmux
• démarrage automatique de tmux lorsque l'ordinateur / serveur est allumé
• restauration automatique au démarrage de tmux

Vous pouvez utiliser des hooks tmux pour exécuter des commandes lorsqu'une nouvelle session est créée. Plus précisément, cela est réalisé en utilisant le session-createdcrochet.

Par exemple, pour diviser l'écran de trois manières avec htop exécuté en bas à droite, vous pouvez ajouter la ligne suivante à votre ~/.tmux.conffichier:

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

L'avantage de cette méthode est que vous n'avez pas besoin d'exécuter tmux d'une manière spéciale (c'est-à-dire un script shell ou un alias) pour obtenir le résultat souhaité. Vous pouvez également combiner cela avec celui tmux new-session -A -s mysessiondécrit dans cette autre réponse de sorte que les commandes de raccordement ne soient exécutées que lorsque vous créez la session pour la première fois et non sur les pièces jointes suivantes.

Cette fonctionnalité a été ajoutée par d15d54c2c en 2016. La première version à l'inclure est la 2.4.

Vous devez le spécifier dans votre fichier de configuration tmux ( ~/.tmux.conf), par exemple:

new mocp
neww mutt

new -d
neww
neww

(ouvre une session avec 2 fenêtres avec mocp lancé en premier et mutt en deuxième, et une autre session détachée avec 3 fenêtres vides).

J'ai créé ce script . Il n'a pas besoin de tmuxinator, rubis ou autres. C'est juste un script bash, configurable:

Un fichier nommé config devrait contenir quelque chose comme ceci:

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

et le code bash devrait être:

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

J'ai juste essayé d'utiliser toutes les idées de cette page et je n'en ai aimé aucune. Je voulais juste une solution qui a démarré tmux avec un ensemble spécifique de fenêtres lorsque mon terminal s'est ouvert. Je voulais aussi qu'elle soit idempotente, c'est-à-dire que l'ouverture d'une nouvelle fenêtre de terminal reprend la session tmux de la précédente.

Les solutions ci-dessus ont souvent tendance à ouvrir plusieurs sessions tmux et je n'en veux qu'une. Tout d'abord, j'ai ajouté ceci à mon ~/.bash_profile:

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

puis j'ai ajouté ce qui suit à mon ~/.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

maintenant, chaque fois que je démarre un terminal ou que je démarre tmux ou quoi que ce soit, je me reconnecte à la configuration désirée existante (la session nommée default) ou crée une nouvelle session avec cette configuration.

tmuxp prend en charge la configuration de session JSON ou YAML et une API python. Un simple fichier de configuration tmuxp pour créer une nouvelle session dans la syntaxe YAML est:

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

Ce script démarre une session avec le nom "e" et trois fenêtres

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