Comment lire l'intégralité du script shell avant de l'exécuter?

Généralement, si vous éditez un scrpit, toutes les utilisations du script en cours sont sujettes aux erreurs.

Autant que je sache, bash (les autres shells aussi?) Lisent le script de manière incrémentielle. Par conséquent, si vous modifiez le fichier de script en externe, il commence à lire le mauvais contenu. Y a-t-il un moyen de le prévenir?

Exemple:

sleep 20

echo test

Si vous exécutez ce script, bash lira la première ligne (disons 10 octets) et s'endormira. À la reprise, le script peut contenir différents contenus commençant au 10ème octet. Je suis peut-être au milieu d'une ligne dans le nouveau script. Ainsi, le script en cours sera brisé.

Oui, les shells, et bashen particulier, veillent à lire le fichier ligne par ligne, de sorte qu'il fonctionne de la même manière que lorsque vous l'utilisez de manière interactive.

Vous remarquerez que lorsque le fichier ne peut pas être recherché (comme un tube), bashmême lit un octet à la fois pour être sûr de ne pas lire après le \ncaractère. Lorsque le fichier peut être recherché, il optimise en lisant des blocs entiers à la fois, mais en recherchant après \n.

Cela signifie que vous pouvez faire des choses comme:

bash << \EOF
read var
var's content
echo "$var"
EOF

Ou écrivez des scripts qui se mettent à jour. Ce que vous ne pourriez pas faire si cela ne vous donnait pas cette garantie.

Maintenant, il est rare que vous souhaitiez faire de telles choses et, comme vous l'avez découvert, cette fonctionnalité a tendance à gêner plus souvent qu'elle n'est utile.

Pour éviter cela, vous pouvez essayer de vous assurer que vous ne modifiez pas le fichier sur place (par exemple, modifiez une copie et déplacez la copie sur place (comme sed -iou perl -piet certains éditeurs le font par exemple)).

Ou vous pouvez écrire votre script comme:

{
  sleep 20
  echo test
}; exit

(Notez qu'il est important que le exitsoit sur la même ligne que }, bien que vous puissiez aussi le mettre entre les accolades juste avant le dernier).

ou:

main() {
  sleep 20
  echo test
}
main "$@"; exit

Le shell devra lire le script jusqu’à exitavant de commencer à faire quoi que ce soit. Cela garantit que le shell ne lira plus le script.

Cela signifie que tout le script sera stocké dans la mémoire.

Cela peut également affecter l'analyse du script.

Par exemple, dans bash:

export LC_ALL=fr_FR.UTF-8
echo $'St\ue9phane'

Produirait que U + 00E9 codé en UTF-8. Cependant, si vous le changez en:

{
  export LC_ALL=fr_FR.UTF-8
  echo $'St\ue9phane'
}

La \ue9volonté sera développée dans le jeu de caractères qui était en vigueur au moment de l'analyse de la commande et qui, dans ce cas, est antérieure à l' exportexécution de la commande.

Notez également que si la commande sourceaka .est utilisée, avec certains shells, vous aurez le même genre de problème pour les fichiers sourcés.

Ce n'est pas le cas de bashbien dont la sourcecommande lit le fichier complètement avant de l'interpréter. Si vous écrivez bashspécifiquement, vous pouvez en faire usage en ajoutant au début du script:

if [[ ! $already_sourced ]]; then
  already_sourced=1
  source "$0"; exit
fi

(Je ne m'appuierais pas là-dessus, même si, comme vous pouvez l'imaginer, les versions futures bashpourraient changer ce comportement qui peut actuellement être considéré comme une limitation (bash et AT & T ksh sont les seuls shells de type POSIX qui se comportent comme ça autant que l'on peut en juger) et l' already_sourcedastuce est un peu fragile car elle suppose que la variable n'est pas dans l'environnement, sans parler du fait qu'elle affecte le contenu de la variable BASH_SOURCE)

Vous devez simplement supprimer le fichier (c'est-à-dire le copier, le supprimer, renommer la copie en son nom d'origine). En fait, de nombreux éditeurs peuvent être configurés pour le faire à votre place. Lorsque vous modifiez un fichier et que vous enregistrez un tampon modifié dans celui-ci, au lieu de le remplacer, il renomme l'ancien fichier, en crée un nouveau et place le nouveau contenu dans le nouveau fichier. Par conséquent, tout script en cours devrait continuer sans problèmes.

En utilisant un système de contrôle de version simple tel que RCS, qui est facilement disponible pour vim et emacs, vous bénéficiez du double avantage de disposer d'un historique de vos modifications. Le système de paiement devrait par défaut supprimer le fichier actuel et le recréer avec les modes appropriés. (Méfiez-vous des liens durs avec de tels fichiers bien sûr).

La solution la plus simple:

{
  ... your code ...

  exit
}

De cette façon, bash lira l’ensemble du {}bloc avant de l’exécuter et la exitdirective s’assurera que rien ne sera lu en dehors du bloc de code.

Si vous ne voulez pas "exécuter" le script, mais plutôt pour le "trouver", vous avez besoin d'une solution différente. Cela devrait fonctionner alors:

{
  ... your code ...

  return 2>/dev/null || exit
}

Ou si vous souhaitez contrôler directement le code de sortie:

{
  ... your code ...

  ret="$?";return "$ret" 2>/dev/null || exit "$ret"
}

Voilà! Ce script peut être édité, source et exécuté en toute sécurité. Vous devez toujours vous assurer de ne pas le modifier en quelques millisecondes lors de sa lecture initiale.

Preuve de concept. Voici un script qui se modifie lui-même:

cat <<EOF >/tmp/scr
#!/bin/bash
sed  s/[k]ept/changed/  /tmp/scr > /tmp/scr2

# this next line overwites the on disk copy of the script
cat /tmp/scr2 > /tmp/scr
# this line ends up changed.
echo script content kept
EOF
chmod u+x /tmp/scr
/tmp/scr

nous voyons la version modifiée imprimer

En effet, bash chargements conserve un descripteur de fichier à ouvrir au script, de sorte que les modifications apportées au fichier sont immédiatement visibles.

Si vous ne souhaitez pas mettre à jour la copie en mémoire, dissociez le fichier d'origine et remplacez-le.

Une façon de faire est d'utiliser sed -i.

sed -i '' filename

preuve de concept

cat <<EOF >/tmp/scr
#!/bin/bash
sed  s/[k]ept/changed/  /tmp/scr > /tmp/scr2

# this next line unlinks the original and creates a new copy.
sed -i ''  /tmp/scr

# now overwriting it has no immediate effect
cat /tmp/scr2 > /tmp/scr
echo script content kept
EOF

chmod u+x /tmp/scr
/tmp/scr

Si vous utilisez un éditeur pour modifier le script, il suffit peut-être d'activer la fonctionnalité "Conserver une copie de sauvegarde" pour que l'éditeur écrive la version modifiée dans un nouveau fichier au lieu de remplacer le fichier existant.

Envelopper votre script dans un bloc {}est probablement la meilleure option mais nécessite de changer vos scripts.

F=$(mktemp) && cp test.sh $F && bash $F; rm $F;

serait la deuxième meilleure option (en supposant que tmpfs ) l’inconvénient est qu’elle casse $ 0 si vos scripts l’utilisent.

utiliser quelque chose comme F=test.sh; tail -n $(cat "$F" | wc -l) "$F" | bashest moins idéal car il doit garder tout le fichier en mémoire et casser 0 $.

il faut éviter de toucher au fichier d'origine afin que, la dernière fois modifiée, les verrous de lecture et les liens physiques ne soient pas perturbés. De cette façon, vous pouvez laisser un éditeur ouvert pendant l’exécution du fichier et rsync ne contrôlera pas inutilement le fichier pour les sauvegardes et les liens physiques fonctionneront comme prévu.

Le remplacement du fichier en mode édition fonctionnerait, mais il est moins robuste car il n’est pas opposable à d’autres scripts / utilisateurs /. Et encore, cela romprait les liens durs.