web-dev-qa-db-fra.com

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

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

shellproduction-environmenttmux
206
satoru

Vous pouvez écrire un petit script Shell qui lance tmux avec les programmes requis. Dans un script Shell, 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 juste le faire

$ dev-tmux
188
Amjith

J'essayais de créer une grille complexe de volets et je devais gérer le découpage et le fractionnement des volets encore et encore. Voici mes apprentissages:

tmux new-session \;

Vous permet de commencer avec une nouvelle session. Pour le scinder horizontalement ou verticalement, utilisez split-window -h ou -v ultérieurement, comme ceci:

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

Crée 3 panneaux, comme ceci:

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

Pour exécuter des commandes dans ces panneaux, ajoutez-les simplement avec la commande send-keys 'my-command' et C-m qui 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. Nous avons donc rétabli en utilisant last-pane ou dans des fenêtres plus complexes, avec le select-pane -t 1 où 1 est le numéro du volet dans l'ordre créé à partir de 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. En gros, il vous suffit de connaître votre chemin avec split-window et select-pane. Il est également pratique de passer avec -p 75 un pourcentage de la taille du volet créé par split-window afin de mieux contrôler 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 qui ressemble à ça

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

Espérons que cela aide tmux amateurs à l'avenir.

95
Afri

Vous pouvez utiliser différentes sources à partir de votre .tmux.conf comme suit:

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

Et ensuite 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 s'appellerait foo/bar et serait scindée verticalement en deux (50%) avec foo dépassant 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

87
jasonwryan

Utilisez tmuxinator - il vous permet de configurer plusieurs sessions et de choisir celle à lancer à tout moment. Vous pouvez lancer des commandes dans des fenêtres ou des volets particuliers et attribuer 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 README au lien ci-dessus pour une explication complète. 

46
Hamish Downer

voir @ 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
16
locojay
:~$ 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
14
m_majeres

À partir de mon script "get.all", que j'appelle chaque matin pour exécuter une série de travaux "get.XXX" ultérieurs, afin d'actualiser le logiciel que je suis. Certains d'entre eux sont auto-quittant. 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
10
Randal Schwartz

Si vous souhaitez simplement diviser l'écran en deux volets (par exemple horizontalement), vous pouvez exécuter cette commande (aucun script tmux ou Shell n'est 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
8
ks1322

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

J'ai donc créé une fonction 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 chacune un environnement de développement différent. Donc, avec la fonction alias ci-dessus, je peux simplement appeler: tmx company1 et charger la configuration dont j'ai besoin.

Update: L'objectif de "$ 2" après la commande tmux est que vous puissiez transmettre des arguments tmux supplémentaires.

8
danbruegge

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 aussi les grouper pour en avoir quelques-uns au travail, des projets de loisir.

Vous pouvez aussi le déplacer dans le dossier ~/bin, l'ajouter à PATH et donner le nom tmux_my_awesome_project. Ensuite, vous pourrez le lancer à partir de chaque endroit.

4
Artur Małecki

Cela fonctionne pour moi. Créer 5 fenêtres avec les noms donnés et sélectionner automatiquement la fenêtre home.

new  -n home
neww -n emacs
neww -n puppet
neww -n haskell
neww -n Ruby
selectw -t 1
4
cevaris

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

Caractéristiques:

  • enregistrement continu de l'environnement tmux 
  • démarrage automatique de tmux lorsque l'ordinateur/le serveur est allumé 
  • restauration automatique au démarrage de tmux

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

tmux-resurrect enregistre tous les petits détails de votre environnement tmux il peut donc être complètement restauré après un redémarrage du système (ou lorsque vous en avez l’impression). Aucune configuration n'est requise. Vous devriez vous sentir comme vous ne quitte jamais tmux.

1
Padhraic

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

session_name: 2-pane-vertical
windows:
  - window_name: my test window
    panes:
      - pwd
      - pwd
1
Miguel de Val-Borro

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 isolée avec 3 fenêtres vides).

1
Victor Deryagin

J'ai créé ce script . Il n’a pas besoin de tmuxinator, Ruby ou d’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
1
sensorario

Il existe un plugin tmux pour cela.

Départ tmux-resurrect

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

Tmux est génial, sauf lorsque 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. Il existe des outils de gestion utiles, mais ils nécessitent une configuration initiale et des mises à jour continues au fur et à mesure de l'évolution de votre processus ou du démarrage de nouveaux projets.

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

Caractéristiques:

  • enregistrement continu de l'environnement tmux
  • démarrage automatique de tmux lorsque l'ordinateur/le serveur est allumé
  • restauration automatique au démarrage de tmux
1
Syakur Rahman

Essayez bro , c’est un amorce de projet.

Il fournit des apis faciles pour interagir avec tmux.

Cela ressemble à quelque chose comme ça:

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

0
Asur

Vous pouvez utiliser tmux hooks pour exécuter des commandes lors de la création d'une nouvelle session. En particulier, ceci est réalisé en utilisant le hook session-created.

Par exemple, pour diviser l’écran de trois manières différentes avec htop en bas à droite, vous pouvez ajouter la ligne suivante à votre fichier ~/.tmux.conf:

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

L’avantage de cette méthode est qu’il n’est pas nécessaire d’exécuter tmux de manière spéciale (script shell ou alias) pour obtenir le résultat souhaité. Vous pouvez également combiner cela avec tmux new-session -A -s mysession décrit dans cette autre réponse , de sorte que les commandes de raccordement ne sont 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.

0
kevmitch

J'ai juste essayé d'utiliser toutes les idées sur cette page et je n'ai aimé aucune d'elles. 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 que ce soit idempotent, c’est-à-dire que l’ouverture d’une nouvelle fenêtre de terminal remplace 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. D'abord, j'ai ajouté ceci à mon ~/.bash_profile:

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

alors 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 lance tmux ou autre chose, je rattache la configuration souhaitée existante (la session nommée default) ou crée une nouvelle session avec cette configuration.

0
Phil Hollenback