Я пишу сценарій для автоматизації створення файлів конфігурації для Apache та PHP для власного веб-сервера. Я не хочу використовувати такі графічні інтерфейси, як CPanel або ISPConfig.

У мене є деякі шаблони файлів конфігурації Apache та PHP. Сценарій Bash повинен читати шаблони, робити змінну підстановку та виводити розбір шаблонів у якусь папку. Який найкращий спосіб зробити це? Я можу придумати кілька способів. Який із них найкращий, а може бути, є кілька кращих способів зробити це? Я хочу це зробити в чистому Bash (наприклад, в PHP це легко)

1) Як замінити заповнювачі $ {} у текстовому файлі?

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"

BTW, як я перенаправляю висновок на зовнішній файл тут? Чи потрібно щось уникати, якщо змінні містять, скажімо, лапки?

2) Використання cat & sed для заміни кожної змінної на її значення:

Дано template.txt:

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

Команда:

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

Мені здається погано через те, що потрібно уникати багатьох різних символів, і з багатьма змінними лінія буде занадто довгою.

Чи можете ви придумати якесь інше елегантне та безпечне рішення?

Ви можете скористатися цим:

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

замінити всі ${...}рядки відповідними змінними середовища (не забудьте експортувати їх перед запуском цього сценарію).

Для чистого bash це має працювати (якщо припустимо, що змінні не містять рядків $ {...}):

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

. Рішення, яке не висить, якщо RHS посилається на якусь змінну, на яку посилається сама:

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

ПОПЕРЕДЖЕННЯ : Я не знаю способу правильно обробити введення з NUL в басі або зберегти кількість останніх рядків. Останній варіант представлений таким чином, оскільки оболонки «люблять» бінарний вхід:

1. read буде інтерпретувати зворотні риси.
2. read -r не інтерпретуватиме косої риски, але все одно викине останній рядок, якщо він не закінчується новим рядком.
3. "$(…)"буде смуга , як багато хвостових символів нового рядка , як там присутній, так що в кінцевому …з ; echo -n aі використанням echo -n "${line:0:-1}": це краплі останнього символу (який a) і зберігають як багато хвостових символів нового рядка , оскільки не було на вході ( в тому числі немає).

Спробуйте envsubst

FOO=foo
BAR=bar
export FOO BAR

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

envsubst був для мене новим. Фантастичний.

Для запису використання heredoc є прекрасним способом шаблонування конф-файлів.

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

Я згоден з використанням sed: це найкращий інструмент для пошуку / заміни. Ось мій підхід:

$ 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

Я думаю, що eval працює дуже добре. Він обробляє шаблони з рядками, пробілами та всілякими штучками. Якщо ви маєте повний контроль над самими шаблонами, звичайно:

$ 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"

Цей метод, звичайно, слід використовувати обережно, оскільки eval може виконувати довільний код. Запускати це як root, майже не виникає сумніву. Цитати в шаблоні потрібно уникати, інакше вони будуть з'їдені eval.

Ви можете також використовувати тут документи , якщо ви віддаєте перевагу , catщобecho

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

@plockc запропонував рішення, яке дозволяє уникнути проблематики випуску цитати:

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

Редагувати: Видалена частина про запуск цього файлу як root за допомогою sudo ...

Редагувати: Додано коментар про те, як потрібно уникнути цитат, додавши до суміші рішення plockc!

У мене є таке рішення, як могсі, але з heredoc замість herestring, щоб уникнути уникнення подвійних цитат

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

Редагувати 6 січня 2017 року

Мені потрібно було зберегти подвійні лапки у моєму файлі конфігурації, щоб подвійні збігаються подвійні лапки з sed допомагали:

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

Я не можу думати про те, щоб зберігати нові рядки, але порожні рядки між ними зберігаються.

Хоча це давня тема, IMO я знайшов тут більш елегантне рішення: 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

Усі кредити Грегорі Пакошу .

Замість того, щоб винаходити колесо, їдьте з envsubst Може використовуватися майже в будь-якому сценарії, наприклад, будувати файли конфігурації зі змінних оточуючих середовищ у контейнерах докера.

Якщо на mac переконайтеся, що у вас є домашня мова, тоді зв’яжіть її з 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

Тепер просто використовуйте його:

# 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

Більш довга, але надійніша версія прийнятої відповіді:

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

Це розширює всі екземпляри $VAR або ${VAR} їхні значення середовища (або, якщо вони не визначені, порожній рядок).

Він належним чином ухиляється від косої косої риси та приймає $, що ухилився від косої риски, щоб придушити заміну (на відміну від envsubst, що, виявляється, цього не робить ).

Отже, якщо ваше оточення:

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

і ваш шаблон:

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

результатом буде:

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

Якщо ви хочете уникнути відхилення від косої риски лише до $ (ви можете написати "C: \ Windows \ System32" у шаблоні без змін), використовуйте цю трохи змінену версію:

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

Я зробив би це так, напевно, менш ефективно, але легше читати / підтримувати.

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

Якщо ви хочете використовувати шаблони Jinja2 , перегляньте цей проект: j2cli .

Він підтримує:

• Шаблони з файлів JSON, INI, YAML та вхідних потоків
• Шаблони із змінних середовища

Отримавши відповідь від ZyX за допомогою чистого bash, але з новим стилем регулярних виразів та непрямою підстановкою параметрів, це стає:

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

Якщо використання Perl - це варіант, і ви задовольняєтесь основою розширень лише на змінних середовища (на відміну від усіх змінних оболонок ), врахуйте надійну відповідь Стюарта П. Бентлі .

Ця відповідь має на меті створити єдине рішення, яке, незважаючи на використання, evalмає бути безпечним у використанні .

Ці цілі є:

• Підтримка розширення обох ${name}та $nameзмінних посилань.
• Запобігти всі інші розширення:
  • підстановки команд ( $(...)і застарілий синтаксис`...` )
  • арифметичні підстановки ( $((...))і застарілий синтаксис $[...]).
• Дозволити вибіркове придушення змінної розширення за допомогою префіксації \(\${name} ).
• Зберегти спеціальні символи. у вхідному документі, зокрема, "і \примірники.
• Дозволити введення або через аргументи, або через stdin.

ФункціяexpandVars() :

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' '`(['
}

Приклади:

$ 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

• З міркувань продуктивності функція зчитує вхід stdin відразу в пам'ять, але легко адаптувати функцію до підходу по лінії.
• Також підтримує неосновні розширення змінних, такі як ${HOME:0:10}, якщо вони не містять вбудованих команд чи арифметичних підстановок, таких як${HOME:0:$(echo 10)}
  • Такі вбудовані підстановки насправді BREAK функції (тому що всі $(і` екземпляри сліпо виконуються).
  • Аналогічно, неправильно сформовані посилання змінних, такі як ${HOME(відсутність закриття }) BREAK функції.
• Завдяки обробці bash з подвійними цитатами, рядки обробляються наступним чином:
  • \$name запобігає розширенню.
  • Сингл, \за яким не слідує, $зберігається як є.
  • Якщо ви хочете представляти кілька сусідніх \ екземплярів, ви повинні їх подвоїти ; наприклад:
    • \\-> \- те саме, що просто\
    • \\\\ -> \\
  • Вхід не повинен містити наступне (рідко використовувані символи), які використовуються для внутрішніх цілей: 0x1, 0x2, 0x3.
• В основному існує гіпотетична стурбованість тим, що якщо bash повинен ввести новий синтаксис розширення, ця функція може не запобігти подібним розширенням - див. Нижче рішення, яке не використовується eval.

Якщо ви шукаєте більш обмежувальне рішення, яке підтримує лише${name} розширення, тобто з обов'язковими фігурними дужками, ігнорування $nameпосилань - дивіться цю відповідь мою.

Ось вдосконалена версія єдиного, evalпростого рішення, з прийнятої відповіді :

Поліпшення:

• Підтримка розширення обох ${name}та $nameзмінних посилань.
• Підтримка \змінних посилань змінних, які не слід розширювати.
• На відміну від evalрішення, заснованого вище,
  • неосновні розширення ігноруються
  • неправильно сформовані посилання змінних ігноруються (вони не порушують сценарій)

 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"

Ось ще одне чисте баш-рішення:

• це використання heredoc, так:
  • складність не збільшується через додатково необхідний синтаксис
  • шаблон може включати bash-код
    • що також дозволяє правильно відступати речі. Дивись нижче.
• він не використовує eval, тому:
  • жодних проблем із рендерінгом порожніх рядків
  • немає проблем із цитатами в шаблоні

$ cat code

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

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

cat_template template | LISTING="$LISTING" bash

$ cat template (з останніми рядками та подвійними лапками)

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

вихід

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

Ось ще одне рішення: генеруйте bash-скрипт із усіма змінними та вмістом файлу шаблону, щоб цей сценарій виглядав так:

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

EOF                

Якщо ми введемо цей скрипт у bash, він отримає потрібний результат:

the number is 1
the word is dog

Ось як генерувати цей скрипт і подавати його в bash:

(
    # Variables
    echo word=dog
    echo i=1

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

Обговорення

• В дужках відкривається допоміжна оболонка, її мета - згрупувати весь генерований результат
• В межах під оболонки ми генеруємо всі декларації змінних
• Також у під оболонці ми генеруємо catкоманду за допомогою HEREDOC
• Нарешті, ми подаємо вихідний сигнал оболонки на баш і виробляємо потрібний вихід

• Якщо ви хочете перенаправити цей вихід у файл, замініть останній рядок на:

  ) | bash > output.txt

На цій сторінці описано відповідь з awk

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

Ідеальний випадок для shtpl . (мій проект, тому він широко не використовується і не вистачає в документації. Але ось рішення, яке він пропонує, як би там не було. Ви можете перевірити його.)

Просто виконайте:

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

Результат:

the number is 1
the word is dog

Весело.

# 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"
}

Це чиста функція bash, що регулюється на ваш смак, використовується у виробництві і не має ламатися на будь-якому вході. Якщо вона зламається - дайте мені знати.

Ви також можете використовувати bashible (який внутрішньо використовує підхід оцінювання, описаний вище / нижче).

Є приклад, як генерувати HTML з кількох частин:

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

Ось функція bash, яка зберігає пробіли:

# 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}"
}

Ось модифікований perlсценарій на основі кількох інших відповідей:

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

Особливості (на основі моїх потреб, але їх слід легко змінити):

• Пропускає розширені параметри розширень (наприклад, \ $ {VAR}).
• Підтримується розширення параметрів форми $ {VAR}, але не $ VAR.
• Замінює $ {VAR} порожнім рядком, якщо немає envar VAR.
• У імені підтримуються лише символи az, AZ, 0-9 та підкреслення (за винятком цифр у першій позиції).

Подивіться на прості сценарії python для заміни змінних тут: https://github.com/jeckep/vsubst

Користуватися дуже просто:

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

Щоб продовжити відповідь на plockc на цій сторінці, ось версія, що підходить для тире, для тих, хто хоче уникати башизмів.

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

Неможливо отримати простіше, ніж:

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

Дивіться https://github.com/relaxdiego/renderest

Мій скромний внесок у це чудове запитання.

tpl() {
    local file=$(cat - | \
                 sed -e 's/\"/\\"/g' \
                     -e "s/'/\\'/g")
    local vars=$(echo ${@} | tr ' ' ';')
    echo "$(sh -c "${vars};echo \"$file\"")"
}

cat tpl.txt | tpl "one=fish" "two=fish"

Це, по суті, працює, використовуючи допоміжну оболонку для заміни envar, за винятком того, що вона не використовує eval, і явно уникає одинарних та подвійних лапок. Він об'єднує вирази var в один рядок без пробілів, щоб не плутати, shа потім передає шаблон echo, дозволяючи shобробляти замін var. Він зберігає нові рядки, коментарі тощо ... і ви можете втекти, \${like_this}якщо не хочете, щоб вар був інтерпретований. ${missing_var}буде просто замінено порожнім значенням.

Багато інших відповідей тут дуже хороші, але я хотів чогось дуже простого, і для цього не потрібно обробляти буквально кожен можливий випадок шаблонів, які я маю на даний момент.

Насолоджуйтесь!