Préserver l'historique bash dans plusieurs fenêtres de terminal

J'ai toujours plus d'un terminal ouvert. N'importe où de deux à dix, faisant divers morceaux et bobs. Maintenant, disons que je redémarre et ouvre un autre ensemble de terminaux. Certains se souviennent de certaines choses, d'autres oublient.

Je veux une histoire qui:

• Se souvient de tout de chaque terminal
• Est instantanément accessible à partir de chaque terminal (par exemple, si je suis lsdans un, passez à un autre terminal déjà en marche puis appuyez sur le haut, lss'affiche)
• N'oubliez pas la commande s'il y a des espaces à l'avant de la commande.

Tout ce que je peux faire pour que Bash fonctionne plus comme ça?

Ajouter ce qui suit à ~ / .bashrc

# Avoid duplicates
export HISTCONTROL=ignoredups:erasedups  
# When the shell exits, append to the history file instead of overwriting it
shopt -s histappend

# After each command, append to the history file and reread it
export PROMPT_COMMAND="${PROMPT_COMMAND:+$PROMPT_COMMAND$'\n'}history -a; history -c; history -r"

Donc, tout cela est lié à mon histoire .bashrc:

export HISTCONTROL=ignoredups:erasedups  # no duplicate entries
export HISTSIZE=100000                   # big big history
export HISTFILESIZE=100000               # big big history
shopt -s histappend                      # append to history, don't overwrite it

# Save and reload the history after each command finishes
export PROMPT_COMMAND="history -a; history -c; history -r; $PROMPT_COMMAND"

Testé avec bash 3.2.17 sur Mac OS X 10.5, bash 4.1.7 sur 10.6.

Voici ma tentative de partage de l'historique de session Bash. Cela permettra le partage de l'historique entre les sessions bash de manière à ce que le compteur d'historique ne soit pas mélangé et que l'expansion de l'historique !numberne fonctionne pas (avec certaines contraintes).

Utilisation de Bash version 4.1.5 sous Ubuntu 10.04 LTS (Lucid Lynx).

HISTSIZE=9000
HISTFILESIZE=$HISTSIZE
HISTCONTROL=ignorespace:ignoredups

_bash_history_sync() {
    builtin history -a         #1
    HISTFILESIZE=$HISTSIZE     #2
    builtin history -c         #3
    builtin history -r         #4
}

history() {                  #5
    _bash_history_sync
    builtin history "$@"
}

PROMPT_COMMAND=_bash_history_sync

Explication:

1. Ajoute la ligne qui vient d'être entrée à la $HISTFILE(valeur par défaut .bash_history). Cela fera $HISTFILEcroître d'une ligne.

2. Si vous définissez la variable spéciale $HISTFILESIZEsur une valeur quelconque, Bash ne tronquera $HISTFILEpas plus de $HISTFILESIZElignes en supprimant les entrées les plus anciennes.

3. Effacer l'historique de la session en cours. Cela réduira le compteur d'historique du montant de $HISTSIZE.

4. Lisez le contenu de $HISTFILEet insérez-le dans l'historique de la session en cours. cela relèvera le compteur d’histoire du nombre de lignes contenues $HISTFILE. Notez que le nombre de lignes de $HISTFILEn'est pas nécessairement $HISTFILESIZE.

5. La history()fonction remplace l'historique intégré pour s'assurer que l'historique est synchronisé avant qu'il ne soit affiché. Ceci est nécessaire pour l’extension de l’historique par numéro (plus à ce sujet plus tard).

Plus d'explication:

• L'étape 1 garantit que la commande de la session en cours d'exécution est écrite dans le fichier historique global.

• L'étape 4 garantit que les commandes des autres sessions sont lues dans l'historique de la session en cours.

• L'étape 4 augmentant le compteur d'historique, nous devons le réduire d'une manière ou d'une autre. Ceci est fait à l'étape 3.

• À l'étape 3, le compteur d'historique est réduit de $HISTSIZE. À l'étape 4, le compteur d'historique est généré par le nombre de lignes insérées $HISTFILE. À l'étape 2, nous nous assurons que le nombre de lignes de $HISTFILEest exactement $HISTSIZE(cela signifie que cela $HISTFILESIZEdoit être identique à $HISTSIZE).

A propos des contraintes de l'expansion de l'histoire:

Lorsque vous utilisez l’extension d’historique par numéro, vous devez toujours rechercher le numéro immédiatement avant de l’utiliser. Cela signifie qu'aucune invite bash ne s'affiche entre la recherche du numéro et son utilisation. Cela signifie généralement pas d'entrée et pas de ctrl + c.

En règle générale, une fois que vous avez plus d'une session Bash, rien ne garantit qu'une extension d'historique numérotée conserve sa valeur entre deux affichages d'invite Bash. Parce que quand PROMPT_COMMANDest exécuté, l'historique de toutes les autres sessions Bash est intégré à l'historique de la session en cours. Si une autre session bash a une nouvelle commande, les numéros d'historique de la session en cours seront différents.

Je trouve cette contrainte raisonnable. Quoi qu'il en soit, je dois regarder le numéro chaque fois parce que je ne me souviens pas de chiffres historiques arbitraires.

D'habitude j'utilise l'extension d'historique par numéro comme ceci

$ history | grep something #note number
$ !number

Je recommande d'utiliser les options suivantes de Bash.

## reedit a history substitution line if it failed
shopt -s histreedit
## edit a recalled history line before executing
shopt -s histverify

Bugs étranges:

L'exécution de la commande d'historique associée à quoi que ce soit aura pour résultat que cette commande sera répertoriée deux fois dans l'historique. Par exemple:

$ history | head
$ history | tail
$ history | grep foo
$ history | true
$ history | false

Tous seront répertoriés dans l'historique deux fois. Je ne sais pas pourquoi.

Idées d'améliorations:

• Modifiez la fonction _bash_history_sync()pour qu’elle ne s’exécute pas à chaque fois. Par exemple, il ne devrait pas s'exécuter après CTRL+Cl'invite. J'utilise souvent CTRL+Cde supprimer une longue ligne de commande quand je décide que je ne veux pas exécuter cette ligne. Parfois, je dois utiliser CTRL+Cpour arrêter un script d'achèvement Bash.

• Les commandes de la session en cours doivent toujours être les plus récentes de l'historique de la session en cours. Cela aura également pour effet secondaire qu'un numéro d'historique donné conserve sa valeur pour les entrées d'historique de cette session.

Je ne suis au courant d'aucune façon d'utiliser bash. Mais c'est l'une des fonctionnalités les plus populaires de zsh.
Personnellement, je préfère zshplus, bashalors je recommande de l'essayer.

Voici la partie de mon .zshrcqui traite de l'histoire:

SAVEHIST=10000 # Number of entries
HISTSIZE=10000
HISTFILE=~/.zsh/history # File
setopt APPEND_HISTORY # Don't erase history
setopt EXTENDED_HISTORY # Add additional data to history like timestamp
setopt INC_APPEND_HISTORY # Add immediately
setopt HIST_FIND_NO_DUPS # Don't show duplicates in search
setopt HIST_IGNORE_SPACE # Don't preserve spaces. You may want to turn it off
setopt NO_HIST_BEEP # Don't beep
setopt SHARE_HISTORY # Share history between session/terminals

Pour ce faire, vous devrez ajouter deux lignes à votre ~/.bashrc:

shopt -s histappend
PROMPT_COMMAND="history -a;history -c;history -r;$PROMPT_COMMAND"

De man bash:

Si l'option de shell histappend est activée (voir la description de shopt sous SHELL BUILTIN COMMANDS ci-dessous), les lignes sont ajoutées au fichier d'historique, sinon le fichier d'historique est écrasé.

Vous pouvez modifier votre invite BASH pour exécuter les "history -a" et "history -r" proposés par Muerr:

savePS1=$PS1

(au cas où vous gâcher quelque chose, ce qui est presque garanti)

PS1=$savePS1`history -a;history -r`

(notez qu'il s'agit de contrôles en arrière-plan; ils exécuteront l'historique -a et l'historique -r à chaque invite. Comme ils ne génèrent aucun texte, votre invite ne sera pas modifiée.

Une fois que vous avez configuré votre variable PS1 comme vous le souhaitez, définissez-la définitivement dans votre fichier ~ / .bashrc.

Si vous souhaitez revenir à votre invite d'origine lors du test, procédez comme suit:

PS1=$savePS1

J'ai effectué des tests de base sur cette opération pour vérifier son efficacité, mais je ne peux parler d'aucun effet secondaire résultant de son exécution history -a;history -rà chaque invite.

Si vous avez besoin d'une solution de synchronisation de l'historique bash ou zsh qui résout également le problème ci-dessous, consultez-la à l' adresse http://ptspts.blogspot.com/2011/03/how-to-automatically-synchronize-shell.html.

Le problème est le suivant: J'ai deux fenêtres de shell A et B. Dans la fenêtre de shell A, je cours sleep 9999et (sans attendre la fin du sommeil) dans la fenêtre de shell B, je veux pouvoir voir sleep 9999l'historique de bash.

La plupart des solutions proposées ici ne résoudront pas ce problème car elles écrivent leurs modifications d'historique dans le fichier d'historique en utilisant PROMPT_COMMANDou PS1, les deux s'exécutant trop tard, uniquement après la fin de la sleep 9999commande.

Vous pouvez utiliser history -apour ajouter l'historique de la session en cours à l'historique, puis utiliser history -rsur les autres terminaux pour lire l'historique. 

Bon, finalement, cela m'a agacé de trouver une solution décente:

# Write history after each command
_bash_history_append() {
    builtin history -a
}
PROMPT_COMMAND="_bash_history_append; $PROMPT_COMMAND"

Ce que cela fait est en quelque sorte une fusion de ce qui a été dit dans ce fil, sauf que je ne comprends pas pourquoi rechargerais l'historique global après chaque commande. Je me soucie très rarement de ce qui se passe dans les autres terminaux, mais je lance toujours une série de commandes, disons dans un terminal:

make
ls -lh target/*.foo
scp target/artifact.foo vm:~/

(Exemple simplifié)

Et dans un autre:

pv ~/test.data | nc vm:5000 >> output
less output
mv output output.backup1

Pas question que je veuille que la commande soit partagée

Voici une alternative que j'utilise. C'est fastidieux mais cela résout le problème mentionné par @axel_c: vous souhaiterez parfois avoir une instance d'historique distincte dans chaque terminal (une pour make, une pour la surveillance, une pour vim, etc.).

Je conserve un fichier d'historique annexé distinct que je mets à jour en permanence. J'ai mappé ce qui suit sur un raccourci clavier:

history | grep -v history >> ~/master_history.txt

Ceci ajoute tout l'historique du terminal actuel à un fichier appelé master_history.txt dans votre répertoire personnel.

J'ai aussi un raccourci clavier séparé pour rechercher dans le fichier d'historique principal:

cat /home/toby/master_history.txt | grep -i

J'utilise un chat | grep car il laisse le curseur à la fin pour entrer dans ma regex. Une façon moins laide de le faire serait d’ajouter quelques scripts sur votre chemin pour accomplir ces tâches, mais les raccourcis clavier fonctionnent à mes fins. Je vais aussi périodiquement extraire l'historique des autres hôtes sur lesquels j'ai travaillé et l'ajouter à mon fichier master_history.txt.

Il est toujours agréable de pouvoir rapidement rechercher et trouver cette regex complexe que vous avez utilisée ou cet étrange perl one-liner que vous avez créé il y a 7 mois.

Je peux proposer un correctif pour ce dernier problème: assurez-vous que la variable env HISTCONTROL ne spécifie pas "ignorespace" (ou "ignoreboth").

Mais je ressens votre douleur avec plusieurs sessions simultanées. Ce n'est tout simplement pas bien géré en Bash.

Voici mon amélioration à la réponse de @ lesmana . La principale différence est que les fenêtres simultanées ne partagent pas l'historique. Cela signifie que vous pouvez continuer à travailler dans vos fenêtres sans que le contexte des autres fenêtres ne soit chargé dans vos fenêtres actuelles.

Si vous tapez explicitement 'historique', OU si vous ouvrez une nouvelle fenêtre, vous obtenez l'historique de toutes les fenêtres précédentes.

De plus, j'utilise cette stratégie pour archiver toutes les commandes jamais tapées sur ma machine.

# Consistent and forever bash history
HISTSIZE=100000
HISTFILESIZE=$HISTSIZE
HISTCONTROL=ignorespace:ignoredups

_bash_history_sync() {
  builtin history -a         #1
  HISTFILESIZE=$HISTSIZE     #2
}

_bash_history_sync_and_reload() {
  builtin history -a         #1
  HISTFILESIZE=$HISTSIZE     #2
  builtin history -c         #3
  builtin history -r         #4
}

history() {                  #5
  _bash_history_sync_and_reload
  builtin history "$@"
}

export HISTTIMEFORMAT="%y/%m/%d %H:%M:%S   "
PROMPT_COMMAND='history 1 >> ${HOME}/.bash_eternal_history'
PROMPT_COMMAND=_bash_history_sync;$PROMPT_COMMAND

J'ai choisi de mettre l'historique dans un fichier à la fois, car plusieurs personnes peuvent travailler sur le même serveur. La séparation des commandes de chaque session facilite l'audit.

# Convert /dev/nnn/X or /dev/nnnX to "nnnX"
HISTSUFFIX=`tty | sed 's/\///g;s/^dev//g'`
# History file is now .bash_history_pts0
HISTFILE=".bash_history_$HISTSUFFIX"
HISTTIMEFORMAT="%y-%m-%d %H:%M:%S "
HISTCONTROL=ignoredups:ignorespace
shopt -s histappend
HISTSIZE=1000
HISTFILESIZE=5000

L'histoire ressemble maintenant à:

user@host:~# test 123
user@host:~# test 5451
user@host:~# history
1  15-08-11 10:09:58 test 123
2  15-08-11 10:10:00 test 5451
3  15-08-11 10:10:02 history

Avec les fichiers ressemblant à:

user@host:~# ls -la .bash*
-rw------- 1 root root  4275 Aug 11 09:42 .bash_history_pts0
-rw------- 1 root root    75 Aug 11 09:49 .bash_history_pts1
-rw-r--r-- 1 root root  3120 Aug 11 10:09 .bashrc

Ici, je vais signaler un problème avec

export PROMPT_COMMAND="${PROMPT_COMMAND:+$PROMPT_COMMAND$'\n'}history -a; history -c; history -r"

et

PROMPT_COMMAND="$PROMPT_COMMAND;history -a; history -n"

Si vous utilisez la source ~ / .bashrc, le $ PROMPT_COMMAND sera comme

"history -a; history -c; history -r history -a; history -c; history -r"

et

"history -a; history -n history -a; history -n"

Cette répétition se produit chaque fois que vous exécutez 'source ~ / .bashrc'. Vous pouvez vérifier PROMPT_COMMAND après chaque fois que vous exécutez 'source ~ / .bashrc' en exécutant 'echo $ PROMPT_COMMAND'.

Vous pouvez voir que certaines commandes sont apparemment brisées: "history -n history -a". Mais la bonne nouvelle est que cela fonctionne toujours, car d'autres pièces forment toujours une séquence de commandes valide (entraînant simplement des coûts supplémentaires en raison de l'exécution répétitive de commandes. Et pas si propre.)

Personnellement j'utilise la version simple suivante:

shopt -s histappend
PROMPT_COMMAND="history -a; history -c; history -r"

qui a la plupart des fonctionnalités alors aucun problème tel que mentionné ci-dessus.

Un autre point à souligner est qu’il n’ya vraiment rien de magique . PROMPT_COMMAND n'est qu'une simple variable d'environnement bash. Les commandes qu'il contient sont exécutées avant que vous obteniez prompt bash (le signe $). Par exemple, votre PROMPT_COMMAND est "echo 123" et vous exécutez "ls" dans votre terminal. L'effet est similaire à l'exécution de "ls; echo 123".

$ PROMPT_COMMAND="echo 123"

output (comme si vous exécutiez 'PROMPT_COMMAND = "echo 123"; $ PROMPT_COMMAND'):

123

Exécutez ce qui suit:

$ echo 3

sortie:

3
123

"history -a" est utilisé pour écrire les commandes d'historique en mémoire dans ~ / .bash_history

"history -c" est utilisé pour effacer les commandes d'historique en mémoire

"history -r" est utilisé pour lire les commandes d'historique de ~ / .bash_history dans la mémoire

Voir l'explication des commandes d'historique ici: http://ss64.com/bash/history.html

PS: Comme d'autres utilisateurs l'ont souligné, l' exportation n'est pas nécessaire. Voir: utilisation de l'export dans .bashrc

J'ai écrit un script pour définir un fichier d'historique par session ou tâche, en fonction des éléments suivants.

        # write existing history to the old file
        history -a

        # set new historyfile
        export HISTFILE="$1"
        export HISET=$1

        # touch the new file to make sure it exists
        touch $HISTFILE
        # load new history file
        history -r $HISTFILE

Il n’est pas nécessaire de sauvegarder toutes les commandes de l’historique, mais il enregistre celles qui me tiennent à cœur et il est plus facile de les récupérer que de passer en revue chaque commande. Ma version répertorie également tous les fichiers d’historique et offre la possibilité de les parcourir tous.

Source complète: https://github.com/simotek/scripts-config/blob/master/hiset.sh

Voici une solution qui ne mélange pas l'historique des sessions individuelles!

Fondamentalement, il faut stocker l'historique de chaque session séparément et le recréer à chaque invite. Oui, il utilise plus de ressources, mais ce n'est pas aussi lent que cela puisse paraître - le retard commence à être perceptible uniquement si vous avez plus de 100 000 entrées dans l'historique.

Voici la logique de base:

# on every prompt, save new history to dedicated file and recreate full history
# by reading all files, always keeping history from current session on top.
update_history () {
  history -a ${HISTFILE}.$$
  history -c
  history -r
  for f in `ls ${HISTFILE}.[0-9]* | grep -v "${HISTFILE}.$$\$"`; do
    history -r $f
  done
  history -r "${HISTFILE}.$$"
}
export PROMPT_COMMAND='update_history'

# merge session history into main history file on bash exit
merge_session_history () {
  cat ${HISTFILE}.$$ >> $HISTFILE
  rm ${HISTFILE}.$$
}
trap merge_session_history EXIT

Consultez cette synthèse pour une solution complète, comprenant des garanties et des optimisations de performances.

Cela fonctionne pour ZSH

##############################################################################
# History Configuration for ZSH
##############################################################################
HISTSIZE=10000               #How many lines of history to keep in memory
HISTFILE=~/.zsh_history     #Where to save history to disk
SAVEHIST=10000               #Number of history entries to save to disk
#HISTDUP=erase               #Erase duplicates in the history file
setopt    appendhistory     #Append history to the history file (no overwriting)
setopt    sharehistory      #Share history across terminals
setopt    incappendhistory  #Immediately append to the history file, not just when a term is killed

Je voulais depuis longtemps cela, en particulier la possibilité de récupérer une commande en fonction de son exécution afin de l'exécuter à nouveau dans un nouveau projet (ou de rechercher un répertoire à l'aide d'une commande). J'ai donc assemblé cet outil , qui combine les solutions précédentes pour stocker un historique global de la CLI avec un outil de capture interactif appelé percol (mappé sur C ^ R). La première machine que je commence à utiliser est toujours lisse, maintenant avec un historique CLI âgé de plus de 2 ans.

En ce qui concerne les touches fléchées, il ne perturbe pas l’historique local de la CLI, mais vous permet d’accéder assez facilement à l’historique global (que vous pouvez également mapper sur autre chose que C ^ R).

Parce que je préfère une histoire infinie qui est enregistrée dans un fichier personnalisé. Je crée cette configuration sur https://stackoverflow.com/a/19533853/4632019 :

export HISTFILESIZE=
export HISTSIZE=
export HISTTIMEFORMAT="[%F %T] "

export HISTFILE=~/.bash_myhistory
PROMPT_COMMAND="history -a; history -r; $PROMPT_COMMAND"

Voici l'extrait de mon .bashrc et de courtes explications là où c'est nécessaire:

# The following line ensures that history logs screen commands as well
shopt -s histappend

# This line makes the history file to be rewritten and reread at each bash prompt
PROMPT_COMMAND="$PROMPT_COMMAND;history -a; history -n"
# Have lots of history
HISTSIZE=100000         # remember the last 100000 commands
HISTFILESIZE=100000     # start truncating commands after 100000 lines
HISTCONTROL=ignoreboth  # ignoreboth is shorthand for ignorespace and     ignoredups

HISTFILESIZE et HISTSIZE sont des préférences personnelles et vous pouvez les modifier selon vos goûts.