¿Plantillas con Linux en un script de Shell?

Solución 1:

Esto es muy posible. Una forma muy sencilla de implementar esto sería que el archivo de plantilla fuera realmente el script y usara variables de shell como

#! /bin/bash
version="1.2.3"
path="/foo/bar/baz"
cat > /tmp/destfile <<-EOF
here is some config for version $version which should
also reference this path $path
EOF

Incluso podría hacer que esto sea configurable en la línea de comandos especificando version=$1 y path=$2 , para que pueda ejecutarlo como bash script /foo/bar/baz 1.2.3 . El - antes de que EOF provoque espacios en blanco antes de que se ignoren las líneas, use <<EOF sin formato si no desea ese comportamiento.

Otra forma de hacer esto sería usar la función de búsqueda y reemplazo de sed

#! /bin/bash
version="1.2.3"
path="/foo/bar/baz"
sed -e "s/VERSION/$version/g" -e "s/PATH/$path/" /path/to/templatefile > /tmp/destfile

que reemplazaría cada instancia de las cadenas VERSIÓN y RUTA. Si hay otras razones por las que esas cadenas estarían en el archivo de plantilla, puede hacer que su búsqueda y reemplazo sea VERSION o %VERSION% o algo menos probable que se active accidentalmente.

Solución 2:

La forma más fácil de hacer esto simplemente en la CLI de Linux es usar envsubst y variables de entorno.

Archivo de plantilla de ejemplo apache.tmpl :

<VirtualHost *:${PORT}>
    ServerName ${SERVER_NAME}
    ServerAlias ${SERVER_ALIAS}
    DocumentRoot "${DOCUMENT_ROOT}"
</VirtualHost>

Ejecute envsubst y enviar el resultado a un nuevo archivo my_apache_site.conf :

export PORT="443"
export SERVER_NAME="example.com"
export SERVER_ALIAS="www.example.com"
export DOCUMENT_ROOT="/var/www/html/"
envsubst < apache.tmpl > my_apache_site.conf

Salida:

<VirtualHost *:443>
    ServerName example.com
    ServerAlias www.example.com
    DocumentRoot "/var/www/html/"
</VirtualHost>

Solución 3:

No se necesitan herramientas aparte de /bin/sh . Dado un archivo de plantilla del formulario

Version: ${version}
Path: ${path}

o incluso con código shell mixto incluido

Version: ${version}
Path: ${path}
Cost: ${cost}\$
$(i=1; for w in one two three four; do echo Param${i}: ${w}; i=$(expr $i + 1); done)

y un archivo de configuración analizable de shell como

version="1.2.3-r42"
path="/some/place/under/the/rainbow/where/files/dance/in/happiness"
cost="42"

es una cuestión simple expandir esto a

Version: 1.2.3-r42
Path: /some/place/under/the/rainbow/where/files/dance/in/happiness
Cost: 42$
Param1: one
Param2: two
Param3: three
Param4: four

De hecho, dada la ruta al archivo de configuración en la variable de shell config_file y la ruta al archivo de plantilla en template_file , todo lo que necesitas hacer es:

. ${config_file}
template="$(cat ${template_file})"
eval "echo \"${template}\""

Esto es quizás más bonito que tener un script de shell completo como archivo de plantilla (solución de (@mtinberg).

El completo programa de expansión de plantillas ingenuas:

#!/bin/sh

PROG=$(basename $0)

usage()
{
    echo "${PROG} <template-file> [ <config-file> ]"
}

expand()
{
    local template="$(cat $1)"
    eval "echo \"${template}\""
}

case $# in
    1) expand "$1";;
    2) . "$2"; expand "$1";;
    *) usage; exit 0;;
esac

Esto generará la expansión a la salida estándar; simplemente redirija la salida estándar a un archivo o modifique lo anterior de manera obvia para producir el archivo de salida deseado.

Advertencias: La expansión del archivo de plantilla no funcionaría si el archivo contuviera comillas dobles sin escape (" ). Por razones de seguridad, probablemente deberíamos incluir algunas comprobaciones de cordura obvias o, mejor aún, realizar una transformación de escape de shell si el archivo de plantilla es generado por una entidad externa.

Solución 4:

Si desea plantillas livianas y reales en lugar de código shell que genera nuevos archivos, las opciones habituales son sed &awk o perl . Aquí hay un enlace:http://savvyadmin.com/generate-text-from-templates-scripts-and-csv-data/

Yo, usaría un lenguaje real como perl, tcl, python, ruby ​​o cualquier otro en esa clase. Algo construido para secuencias de comandos. Todos tienen herramientas de plantillas buenas y sencillas y toneladas de ejemplos en google.

Solución 5:

Yo uso shtpl para eso. (proyecto privado mío, lo que significa que no se usa mucho. Pero tal vez quieras probarlo de todos modos)

Por ejemplo, si desea generar un /etc/network/interfaces a partir de un archivo csv, puede hacerlo así:

Contenido del archivo CSV (aquí test.csv):

eth0;10.1.0.10;255.255.0.0;10.1.0.1
eth1;192.168.0.10; 255.255.255.0;192.168.0.1

Plantilla (aquí interfaces.tpl):

#% IFS=';'
#% while read "Val1" "Val2" "Val3" "Val4"; do
auto $Val1 
iface $Val1 inet static
  address $Val2 
  netmask $Val3 
  gateway $Val4 

#% done < "$CSVFILE"

Comando:

$ CSVFILE=test.csv sh -c "$( shtpl interfaces.tpl )"

Resultado:

auto eth0 
iface eth0 inet static
  address 10.1.0.10 
  netmask 255.255.0.0 
  gateway 10.1.0.1 

auto eth1 
iface eth1 inet static
  address 192.168.0.10 
  netmask  255.255.255.0 
  gateway 192.168.0.1

¡Disfrútalo!