Sto scrivendo uno script per automatizzare la creazione di file di configurazione per Apache e PHP per il mio server web. Non voglio usare alcuna GUI come CPanel o ISPConfig.

Ho alcuni modelli di file di configurazione di Apache e PHP. Lo script Bash deve leggere i modelli, effettuare la sostituzione delle variabili e generare modelli analizzati in alcune cartelle. Qual è il modo migliore per farlo? Posso pensare a diversi modi. Qual è il migliore o potrebbe esserci qualche modo migliore per farlo? Voglio farlo in puro Bash (ad esempio in PHP è facile)

1) Come sostituire i segnaposto $ {} in un file di testo?

Template.txt:

the number is ${i}
the word is ${word}

script.sh:

#!/bin/sh

#set variables
i=1
word="dog"
#read in template one line at the time, and replace variables
#(more natural (and efficient) way, thanks to Jonathan Leffler)
while read line
do
    eval echo "$line"
done < "./template.txt"

A proposito, come posso reindirizzare l'output su file esterno qui? Devo sfuggire a qualcosa se le variabili contengono, diciamo, virgolette?

2) Usare cat & sed per sostituire ogni variabile con il suo valore:

Dato template.txt:

The number is ${i}
The word is ${word}

Comando:

cat template.txt | sed -e "s/\${i}/1/" | sed -e "s/\${word}/dog/"

Mi sembra male a causa della necessità di sfuggire a molti simboli diversi e con molte variabili la linea sarà troppo lunga.

Riesci a pensare a qualche altra soluzione elegante e sicura?

Puoi usare questo:

perl -p -i -e 's/\$\{([^}]+)\}/defined $ENV{$1} ? $ENV{$1} : $&/eg' < template.txt

per sostituire tutte le ${...}stringhe con le variabili di ambiente corrispondenti (non dimenticare di esportarle prima di eseguire questo script).

Per puro bash dovrebbe funzionare (supponendo che le variabili non contengano $ {...} stringhe):

#!/bin/bash
while read -r line ; do
    while [[ "$line" =~ (\$\{[a-zA-Z_][a-zA-Z_0-9]*\}) ]] ; do
        LHS=${BASH_REMATCH[1]}
        RHS="$(eval echo "\"$LHS\"")"
        line=${line//$LHS/$RHS}
    done
    echo "$line"
done

. Soluzione che non si blocca se RHS fa riferimento a una variabile che fa riferimento a se stessa:

#!/bin/bash
line="$(cat; echo -n a)"
end_offset=${#line}
while [[ "${line:0:$end_offset}" =~ (.*)(\$\{([a-zA-Z_][a-zA-Z_0-9]*)\})(.*) ]] ; do
    PRE="${BASH_REMATCH[1]}"
    POST="${BASH_REMATCH[4]}${line:$end_offset:${#line}}"
    VARNAME="${BASH_REMATCH[3]}"
    eval 'VARVAL="$'$VARNAME'"'
    line="$PRE$VARVAL$POST"
    end_offset=${#PRE}
done
echo -n "${line:0:-1}"

ATTENZIONE : non conosco un modo per gestire correttamente l'input con NUL in bash o preservare la quantità di nuove righe finali. L'ultima variante è presentata così com'è perché le shell "amano" l'input binario:

1. read interpreterà le barre rovesciate.
2. read -r non interpreterà le barre rovesciate, ma lascerà comunque l'ultima riga se non termina con una nuova riga.
3. "$(…)"spogliamo tutte le nuove righe finali presenti, quindi finisco …con ; echo -n ae uso echo -n "${line:0:-1}": questo lascia cadere l'ultimo carattere (che è a) e conserva tutte le nuove righe finali presenti nell'input (incluso no).

Provare envsubst

FOO=foo
BAR=bar
export FOO BAR

envsubst <<EOF
FOO is $FOO
BAR is $BAR
EOF

envsubst era nuovo per me. Fantastico.

Per la cronaca, usare un heredoc è un ottimo modo per modellare un file conf.

STATUS_URI="/hows-it-goin";  MONITOR_IP="10.10.2.15";

cat >/etc/apache2/conf.d/mod_status.conf <<EOF
<Location ${STATUS_URI}>
    SetHandler server-status
    Order deny,allow
    Deny from all
    Allow from ${MONITOR_IP}
</Location>
EOF

Sono d'accordo con l'utilizzo di sed: è lo strumento migliore per la ricerca / sostituzione. Ecco il mio approccio:

$ cat template.txt
the number is ${i}
the dog's name is ${name}

$ cat replace.sed
s/${i}/5/
s/${name}/Fido/

$ sed -f replace.sed template.txt > out.txt

$ cat out.txt
the number is 5
the dog's name is Fido

Penso che eval funzioni davvero bene. Gestisce modelli con interruzioni di riga, spazi bianchi e ogni sorta di roba bash. Se hai il pieno controllo sui modelli stessi, ovviamente:

$ cat template.txt
variable1 = ${variable1}
variable2 = $variable2
my-ip = \"$(curl -s ifconfig.me)\"

$ echo $variable1
AAA
$ echo $variable2
BBB
$ eval "echo \"$(<template.txt)\"" 2> /dev/null
variable1 = AAA
variable2 = BBB
my-ip = "11.22.33.44"

Questo metodo dovrebbe essere usato con cura, ovviamente, poiché eval può eseguire codice arbitrario. Eseguirlo come root è praticamente fuori discussione. Le citazioni nel modello devono essere evase, altrimenti verranno consumate da eval.

È inoltre possibile utilizzare qui i documenti, se si preferisce cataecho

$ eval "cat <<< \"$(<template.txt)\"" 2> /dev/null

@plockc ha dimostrato una soluzione che evita il problema di evasione della citazione di bash:

$ eval "cat <<EOF
$(<template.txt)
EOF
" 2> /dev/null

Modifica: parte rimossa sull'esecuzione come root usando sudo ...

Modifica: aggiunto commento su come le citazioni devono essere evase, aggiunta la soluzione di plockc al mix!

Ho una soluzione bash come mogsie ma con heredoc invece di herestring per permetterti di evitare le doppie virgolette

eval "cat <<EOF
$(<template.txt)
EOF
" 2> /dev/null

Modifica 6 gennaio 2017

Avevo bisogno di mantenere doppie virgolette nel mio file di configurazione, quindi doppia evasione di doppie virgolette con sed aiuta:

render_template() {
  eval "echo \"$(sed 's/\"/\\\\"/g' $1)\""
}

Non riesco a pensare di continuare a seguire nuove linee, ma le linee vuote nel mezzo vengono mantenute.

Sebbene sia un vecchio argomento, IMO ho scoperto una soluzione più elegante qui: http://pempek.net/articles/2013/07/08/bash-sh-as-template-engine/

#!/bin/sh

# render a template configuration file
# expand variables + preserve formatting
render_template() {
  eval "echo \"$(cat $1)\""
}

user="Gregory"
render_template /path/to/template.txt > path/to/configuration_file

Tutti i crediti a Grégory Pakosz .

Invece di reinventare la ruota, vai con envsubst Può essere usato in quasi tutti gli scenari, ad esempio costruendo file di configurazione da variabili d'ambiente in contenitori docker.

Se su Mac assicurati di avere homebrew , collegalo da gettext:

brew install gettext
brew link --force gettext

./template.cfg

# We put env variables into placeholders here
this_variable_1 = ${SOME_VARIABLE_1}
this_variable_2 = ${SOME_VARIABLE_2}

./.env:

SOME_VARIABLE_1=value_1
SOME_VARIABLE_2=value_2

./configure.sh

#!/bin/bash
cat template.cfg | envsubst > whatever.cfg

Ora basta usarlo:

# make script executable
chmod +x ./configure.sh
# source your variables
. .env
# export your variables
# In practice you may not have to manually export variables 
# if your solution depends on tools that utilise .env file 
# automatically like pipenv etc. 
export SOME_VARIABLE_1 SOME_VARIABLE_2
# Create your config file
./configure.sh

Una versione più lunga ma più solida della risposta accettata:

perl -pe 's;(\\*)(\$([a-zA-Z_][a-zA-Z_0-9]*)|\$\{([a-zA-Z_][a-zA-Z_0-9]*)\})?;substr($1,0,int(length($1)/2)).($2&&length($1)%2?$2:$ENV{$3||$4});eg' template.txt

Questo espande tutte le istanze di $VAR o ${VAR} ai loro valori di ambiente (o, se non sono definiti, la stringa vuota).

Sfugge correttamente alle barre rovesciate e accetta un $ sfuggito alla barra rovesciata per inibire la sostituzione (a differenza di envsubst, che, a quanto pare, non lo fa ).

Quindi, se il tuo ambiente è:

FOO=bar
BAZ=kenny
TARGET=backslashes
NOPE=engi

e il tuo modello è:

Two ${TARGET} walk into a \\$FOO. \\\\
\\\$FOO says, "Delete C:\\Windows\\System32, it's a virus."
$BAZ replies, "\${NOPE}s."

il risultato sarebbe:

Two backslashes walk into a \bar. \\
\$FOO says, "Delete C:\Windows\System32, it's a virus."
kenny replies, "${NOPE}s."

Se si desidera evitare solo barre rovesciate prima di $ (è possibile scrivere "C: \ Windows \ System32" in un modello invariato), utilizzare questa versione leggermente modificata:

perl -pe 's;(\\*)(\$([a-zA-Z_][a-zA-Z_0-9]*)|\$\{([a-zA-Z_][a-zA-Z_0-9]*)\});substr($1,0,int(length($1)/2)).(length($1)%2?$2:$ENV{$3||$4});eg' template.txt

Lo avrei fatto in questo modo, probabilmente meno efficiente, ma più facile da leggere / mantenere.

TEMPLATE='/path/to/template.file'
OUTPUT='/path/to/output.file'

while read LINE; do
  echo $LINE |
  sed 's/VARONE/NEWVALA/g' |
  sed 's/VARTWO/NEWVALB/g' |
  sed 's/VARTHR/NEWVALC/g' >> $OUTPUT
done < $TEMPLATE

Se si desidera utilizzare i modelli Jinja2 , vedere questo progetto: j2cli .

Supporta:

• Modelli da file JSON, INI, YAML e flussi di input
• Templating da variabili d'ambiente

Prendendo la risposta da ZyX usando pure bash ma con il nuovo stile regex matching e la sostituzione indiretta dei parametri diventa:

#!/bin/bash
regex='\$\{([a-zA-Z_][a-zA-Z_0-9]*)\}'
while read line; do
    while [[ "$line" =~ $regex ]]; do
        param="${BASH_REMATCH[1]}"
        line=${line//${BASH_REMATCH[0]}/${!param}}
    done
    echo $line
done

Se usare Perl è un'opzione e ti accontenti di basare le espansioni solo sulle variabili di ambiente (al contrario di tutte le variabili di shell ), considera la solida risposta di Stuart P. Bentley .

Questa risposta mira a fornire una soluzione solo bash che - nonostante l'uso di eval- dovrebbe essere sicura da usare .

Gli obiettivi sono:

• Supporta l'espansione di entrambi ${name}e $nameriferimenti variabili.
• Prevenire tutte le altre espansioni:
  • sostituzioni di comandi ( $(...)e sintassi legacy `...`)
  • sostituzioni aritmetiche ( $((...))e sintassi legacy $[...]).
• Consenti la soppressione selettiva dell'espansione variabile mediante il prefisso con \( \${name}).
• Preserva caratteri speciali. nell'input, in particolare "e nelle \istanze.
• Consenti input tramite argomenti o tramite stdin.

FunzioneexpandVars() :

expandVars() {
  local txtToEval=$* txtToEvalEscaped
  # If no arguments were passed, process stdin input.
  (( $# == 0 )) && IFS= read -r -d '' txtToEval
  # Disable command substitutions and arithmetic expansions to prevent execution
  # of arbitrary commands.
  # Note that selectively allowing $((...)) or $[...] to enable arithmetic
  # expressions is NOT safe, because command substitutions could be embedded in them.
  # If you fully trust or control the input, you can remove the `tr` calls below
  IFS= read -r -d '' txtToEvalEscaped < <(printf %s "$txtToEval" | tr '`([' '\1\2\3')
  # Pass the string to `eval`, escaping embedded double quotes first.
  # `printf %s` ensures that the string is printed without interpretation
  # (after processing by by bash).
  # The `tr` command reconverts the previously escaped chars. back to their
  # literal original.
  eval printf %s "\"${txtToEvalEscaped//\"/\\\"}\"" | tr '\1\2\3' '`(['
}

Esempi:

$ expandVars '\$HOME="$HOME"; `date` and $(ls)'
$HOME="/home/jdoe"; `date` and $(ls)  # only $HOME was expanded

$ printf '\$SHELL=${SHELL}, but "$(( 1 \ 2 ))" will not expand' | expandVars
$SHELL=/bin/bash, but "$(( 1 \ 2 ))" will not expand # only ${SHELL} was expanded

• Per motivi di prestazioni, la funzione legge tutti gli input di stdin contemporaneamente in memoria, ma è facile adattare la funzione ad un approccio riga per riga.
• Supporta anche espansioni di variabili non di base come ${HOME:0:10}, purché non contengano comandi incorporati o sostituzioni aritmetiche, come${HOME:0:$(echo 10)}
  • Tali sostituzioni incorporate in realtà interrompono la funzione (poiché tutte $(e le `istanze sono evitate ciecamente).
  • Allo stesso modo, riferimenti variabili non validi come ${HOME(chiusura mancante }) interrompono la funzione.
• A causa della gestione bash di stringhe tra virgolette, le barre rovesciate vengono gestite come segue:
  • \$name impedisce l'espansione.
  • Un singolo \non seguito da $viene conservato così com'è.
  • Se si desidera rappresentare più \ istanze adiacenti , è necessario raddoppiarle ; per esempio:
    • \\-> \- lo stesso di solo\
    • \\\\ -> \\
  • Caratteri l'ingresso non deve contenere la seguente (raramente usato), che vengono utilizzati per scopi interni: 0x1, 0x2, 0x3.
• C'è una preoccupazione in gran parte ipotetica che se bash dovesse introdurre una nuova sintassi di espansione, questa funzione potrebbe non impedire tali espansioni - vedi sotto per una soluzione che non usa eval.

Se stai cercando una soluzione più restrittiva che supporti solo le ${name}espansioni - ovvero, con parentesi graffe obbligatorie , ignorando i $nameriferimenti - vedi questa mia risposta .

Ecco una versione migliorata della evalsoluzione solo-bash, libera dalla risposta accettata :

I miglioramenti sono:

• Supporto per l'espansione di entrambi ${name}e $nameriferimenti variabili.
• Supporto per \-escape riferimenti a variabili che non dovrebbero essere espansi.
• A differenza della evalsoluzione basata sopra,
  • le espansioni non di base vengono ignorate
  • i riferimenti alle variabili non validi vengono ignorati (non interrompono lo script)

 IFS= read -d '' -r lines # read all input from stdin at once
 end_offset=${#lines}
 while [[ "${lines:0:end_offset}" =~ (.*)\$(\{([a-zA-Z_][a-zA-Z_0-9]*)\}|([a-zA-Z_][a-zA-Z_0-9]*))(.*) ]] ; do
      pre=${BASH_REMATCH[1]} # everything before the var. reference
      post=${BASH_REMATCH[5]}${lines:end_offset} # everything after
      # extract the var. name; it's in the 3rd capture group, if the name is enclosed in {...}, and the 4th otherwise
      [[ -n ${BASH_REMATCH[3]} ]] && varName=${BASH_REMATCH[3]} || varName=${BASH_REMATCH[4]}
      # Is the var ref. escaped, i.e., prefixed with an odd number of backslashes?
      if [[ $pre =~ \\+$ ]] && (( ${#BASH_REMATCH} % 2 )); then
           : # no change to $lines, leave escaped var. ref. untouched
      else # replace the variable reference with the variable's value using indirect expansion
           lines=${pre}${!varName}${post}
      fi
      end_offset=${#pre}
 done
 printf %s "$lines"

Ecco un'altra soluzione pura bash:

• sta usando heredoc, quindi:
  • la complessità non aumenta a causa della sintassi aggiuntiva richiesta
  • il modello può includere il codice bash
    • ciò ti consente anche di indentare correttamente le cose. Vedi sotto.
• non usa eval, quindi:
  • nessun problema con il rendering delle righe vuote finali
  • nessun problema con le virgolette nel modello

$ cat code

#!/bin/bash
LISTING=$( ls )

cat_template() {
  echo "cat << EOT"
  cat "$1"
  echo EOT
}

cat_template template | LISTING="$LISTING" bash

$ cat template (con nuove righe finali e virgolette doppie)

<html>
  <head>
  </head>
  <body> 
    <p>"directory listing"
      <pre>
$( echo "$LISTING" | sed 's/^/        /' )
      <pre>
    </p>
  </body>
</html>

produzione

<html>
  <head>
  </head>
  <body> 
    <p>"directory listing"
      <pre>
        code
        template
      <pre>
    </p>
  </body>
</html>

Ecco un'altra soluzione: generare uno script bash con tutte le variabili e il contenuto del file modello, tale script sarebbe simile al seguente:

word=dog           
i=1                
cat << EOF         
the number is ${i} 
the word is ${word}

EOF                

Se alimentiamo questo script in bash, produrrebbe l'output desiderato:

the number is 1
the word is dog

Ecco come generare quello script e alimentare quello script in bash:

(
    # Variables
    echo word=dog
    echo i=1

    # add the template
    echo "cat << EOF"
    cat template.txt
    echo EOF
) | bash

Discussione

• Le parentesi aprono una sotto-shell, il suo scopo è quello di raggruppare tutto l'output generato
• All'interno della sotto shell generiamo tutte le dichiarazioni delle variabili
• Anche nella sotto shell, generiamo il file cat comando con HEREDOC
• Infine, alimentiamo l'output della sub shell per bash e produciamo l'output desiderato

• Se si desidera reindirizzare questo output in un file, sostituire l'ultima riga con:

  ) | bash > output.txt

Questa pagina descrive una risposta con awk

awk '{while(match($0,"[$]{[^}]*}")) {var=substr($0,RSTART+2,RLENGTH -3);gsub("[$]{"var"}",ENVIRON[var])}}1' < input.txt > output.txt

Custodia perfetta per shtpl . (progetto mio, quindi non è ampiamente utilizzato e manca di documentazione. Ma ecco la soluzione che offre comunque. Ti consigliamo di testarlo.)

Esegui solo:

$ i=1 word=dog sh -c "$( shtpl template.txt )"

Il risultato è:

the number is 1
the word is dog

Divertiti.

# Usage: template your_file.conf.template > your_file.conf
template() {
        local IFS line
        while IFS=$'\n\r' read -r line ; do
                line=${line//\\/\\\\}         # escape backslashes
                line=${line//\"/\\\"}         # escape "
                line=${line//\`/\\\`}         # escape `
                line=${line//\$/\\\$}         # escape $
                line=${line//\\\${/\${}       # de-escape ${         - allows variable substitution: ${var} ${var:-default_value} etc
                # to allow arithmetic expansion or command substitution uncomment one of following lines:
#               line=${line//\\\$\(/\$\(}     # de-escape $( and $(( - allows $(( 1 + 2 )) or $( command ) - UNSECURE
#               line=${line//\\\$\(\(/\$\(\(} # de-escape $((        - allows $(( 1 + 2 ))
                eval "echo \"${line}\"";
        done < "$1"
}

Questa è la funzione bash pura regolabile a proprio piacimento, utilizzata in produzione e non deve interrompere alcun input. Se si rompe, fammi sapere.

Puoi anche usare bashible (che utilizza internamente l'approccio di valutazione descritto sopra / sotto).

C'è un esempio di come generare un HTML da più parti:

https://github.com/mig1984/bashible/tree/master/examples/templates

Ecco una funzione bash che preserva gli spazi bianchi:

# Render a file in bash, i.e. expand environment variables. Preserves whitespace.
function render_file () {
    while IFS='' read line; do
        eval echo \""${line}"\"
    done < "${1}"
}

Ecco uno perlscript modificato basato su alcune delle altre risposte:

perl -pe 's/([^\\]|^)\$\{([a-zA-Z_][a-zA-Z_0-9]*)\}/$1.$ENV{$2}/eg' -i template

Funzionalità (in base alle mie esigenze, ma dovrebbe essere facile da modificare):

• Salta le espansioni di parametri con escape (ad esempio \ $ {VAR}).
• Supporta espansioni di parametri del modulo $ {VAR}, ma non $ VAR.
• Sostituisce $ {VAR} con una stringa vuota se non è presente VAR envar.
• Supporta solo az, AZ, 0-9 e caratteri di sottolineatura nel nome (escluse le cifre nella prima posizione).

Guarda qui lo script python di sostituzione delle variabili semplici: https://github.com/jeckep/vsubst

È molto semplice da utilizzare:

python subst.py --props secure.properties --src_path ./templates --dst_path ./dist

Per dare seguito alla risposta di Plockc in questa pagina, ecco una versione adatta per trattini, per quelli di voi che vogliono evitare i bashismi.

eval "cat <<EOF >outputfile
$( cat template.in )
EOF
" 2> /dev/null

Non può essere più semplice di:

$ person = Bob ./render template.txt> rendering.txt

Vedi https://github.com/relaxdiego/renderest