Come leggere l'intero script della shell prima di eseguirlo?

Di solito, se modifichi uno scrpit, tutti gli usi in esecuzione dello script sono soggetti a errori.

Per quanto ho capito, bash (anche altre shell?) Legge lo script in modo incrementale, quindi se hai modificato il file di script esternamente, inizia a leggere le cose sbagliate. C'è un modo per impedirlo?

Esempio:

sleep 20

echo test

Se esegui questo script, bash leggerà la prima riga (diciamo 10 byte) e andrà a dormire. Quando riprende, ci possono essere diversi contenuti nello script a partire dal decimo byte. Potrei essere nel mezzo di una riga nella nuova sceneggiatura. Pertanto lo script in esecuzione verrà interrotto.

Sì, le shell, e bashin particolare, stanno attenti a leggere il file una riga alla volta, quindi funziona allo stesso modo di quando lo usi in modo interattivo.

Noterai che quando il file non è ricercabile (come una pipe), bashlegge anche un byte alla volta per essere sicuro di non leggere oltre il \ncarattere. Quando il file è ricercabile, si ottimizza leggendo i blocchi completi alla volta, ma cerca nuovamente dopo \n.

Ciò significa che puoi fare cose come:

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

Oppure scrivi script che si aggiornano da soli. Cosa che non saresti in grado di fare se non ti desse quella garanzia.

Ora, è raro che tu voglia fare cose del genere e, come hai scoperto, quella caratteristica tende a interferire più spesso di quanto sia utile.

Per evitarlo, puoi provare ad assicurarti di non modificare il file sul posto (ad esempio, modificare una copia e spostare la copia in posizione (come sed -io perl -pie alcuni editor lo fanno ad esempio)).

Oppure potresti scrivere la tua sceneggiatura come:

{
  sleep 20
  echo test
}; exit

(nota che è importante exitessere sulla stessa linea di }; anche se potresti anche metterlo tra le parentesi appena prima di quello di chiusura).

o:

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

La shell dovrà leggere lo script fino a quando exitprima di iniziare a fare qualsiasi cosa. Ciò garantisce che la shell non leggerà più dallo script.

Ciò significa che l'intero script verrà comunque archiviato in memoria.

Ciò può anche influire sull'analisi dello script.

Ad esempio, in bash:

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

Emetterebbe U + 00E9 codificato in UTF-8. Tuttavia, se lo cambi in:

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

Il \ue9sarà ampliato nel charset che era in vigore al momento che il comando è stato analizzato che in questo caso è prima il exportviene eseguito il comando.

Si noti inoltre che se si utilizza il comando sourceaka ., con alcune shell, si avrà lo stesso tipo di problema per i file di origine.

Questo non è il caso di chi, il bashcui sourcecomando legge il file completamente prima di interpretarlo. Se si scrive in modo bashspecifico, è possibile utilizzarlo aggiungendo all'inizio dello script:

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

(Non farei affidamento su questo, anche se, come puoi immaginare, le versioni future bashpotrebbero cambiare quel comportamento che può essere attualmente visto come una limitazione (bash e AT&T ksh sono le uniche shell tipo POSIX che si comportano in questo modo per quanto ne so) e il already_sourcedtrucco è un po 'fragile in quanto presuppone che la variabile non sia nell'ambiente, per non parlare del fatto che influenza il contenuto della variabile BASH_SOURCE)

Devi semplicemente eliminare il file (cioè copiarlo, eliminarlo, rinominare la copia con il nome originale). In effetti molti editor possono essere configurati per fare questo per te. Quando si modifica un file e si salva un buffer modificato su di esso, invece di sovrascriverlo, il file verrà rinominato, il nuovo verrà creato e il nuovo contenuto verrà inserito nel nuovo file. Quindi qualsiasi script in esecuzione dovrebbe continuare senza problemi.

Usando un semplice sistema di controllo della versione come RCS che è prontamente disponibile per vim ed emacs, ottieni il doppio vantaggio di avere una cronologia delle tue modifiche e il sistema di checkout dovrebbe rimuovere il file corrente e ricrearlo con le modalità corrette per impostazione predefinita. (Fai attenzione a non collegare questi file ovviamente).

La soluzione più semplice:

{
  ... your code ...

  exit
}

In questo modo, bash leggerà l'intero {}blocco prima di eseguirlo e la exitdirettiva farà in modo che nulla venga letto al di fuori del blocco di codice.

Se non si desidera "eseguire" lo script, ma piuttosto "sottrarlo", è necessaria una soluzione diversa. Questo dovrebbe funzionare quindi:

{
  ... your code ...

  return 2>/dev/null || exit
}

O se vuoi il controllo diretto sul codice di uscita:

{
  ... your code ...

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

Ecco! Questo script è sicuro da modificare, creare ed eseguire. Devi ancora essere sicuro di non modificarlo in quei millisecondi quando viene inizialmente letto.

Verifica teorica. Ecco uno script che si modifica da solo:

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

vediamo stampare la versione modificata

Questo perché i carichi di bash mantengono un handle di file da aprire allo script, quindi le modifiche al file verranno visualizzate immediatamente.

Se non si desidera aggiornare la copia in memoria, scollegare il file originale e sostituirlo.

Un modo per farlo è usare sed -i.

sed -i '' filename

verifica teorica

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

Se si utilizza un editor per modificare lo script, abilitare la funzione "conserva una copia di backup" potrebbe essere tutto ciò che è necessario per fare in modo che l'editor scriva la versione modificata in un nuovo file anziché sovrascrivere quello esistente.

Avvolgere lo script in un blocco {}è probabilmente l'opzione migliore ma richiede la modifica degli script.

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

sarebbe la seconda migliore opzione (supponendo tmpfs ) lo svantaggio è che si rompe $ 0 se i tuoi script lo usano.

usare qualcosa di simile F=test.sh; tail -n $(cat "$F" | wc -l) "$F" | bashè meno ideale perché deve mantenere l'intero file in memoria e spezzare $ 0.

toccare il file originale dovrebbe essere evitato in modo che, l'ultima volta modificata, i blocchi di lettura e gli hard link non siano disturbati. in questo modo è possibile lasciare un editor aperto durante l'esecuzione del file e rsync non farà inutilmente il checksum del file per i backup e i collegamenti fissi come previsto.

la sostituzione del file in modifica avrebbe funzionato ma è meno robusta perché non è applicabile ad altri script / utenti / o si potrebbe dimenticare. E di nuovo spezzerebbe i collegamenti duri.