Programación de shell, evitando archivos temporales

A menudo escribo scripts de shell KSH que siguen el mismo patrón:

• (1) recuperar la salida de uno o más comandos
• (2) formatee con grep | cut | awk | sed e imprímalo en la pantalla o en un archivo

Para hacer eso, a menudo almaceno la salida de (1) en un archivo temporal, y luego hago el formato en (2) en ese archivo.

Tome ese código por ejemplo:

TMPFILE=file.tmp

# If tmpfile exists rm it.
[ -f $TMPFILE ] && rm -f $TMPFILE

for SERVICE in $(myfunc); do
    getInfo $SERVICE > $TMPFILE # Store raw output in the TMPFILE

    # I retrieve the relevant data from the TMPFILE
    SERV_NAME=$(head -1 $TMPFILE | sed -e 's/ $//')
    SERV_HOSTNAME=$(grep HOSTNAME $TMPFILE | cut -d "=" -f2)
    SERV_ARGS=$(grep Arguments $TMPFILE | cut -d ":" -f2)

    print $SERV_NAME $SEP $SERV_HOSTNAME $SEP $SERV_ARGS
    rm -f $TMPFILE #rm the TMPFILE in vue of next iteration
done

¿Hay alguna manera, usando tuberías, redirecciones y otras cosas, para evitar escribir un archivo en el disco cada vez?

Si ayuda, estoy usando ksh Versión M-11/16 / 88i

Su código parece un ejemplo completamente justificado de usar archivos temporales para mí. Me quedaría: seguir con este enfoque. Lo único que realmente necesita ser cambiado es la forma en que crea el archivo temporal. Usa algo como

 TMP=$(tempfile)

o

 TMP=$(mktemp)

o al menos

 TMP=/tmp/myscript_$$

De esta manera, no permitirá que el nombre se prediga fácilmente (seguridad) y excluya la interferencia de la regla entre varias instancias del script que se ejecutan al mismo tiempo.

Puedes usar una variable:

info="$(getInfo $SERVICE)"
SERV_NAME="$(head -1 $TMPFILE <<<"$info" | sed -e 's/ $//')"
...

De man ksh:

<<<word       A  short  form of here document in which word becomes the
              contents of the here-document after any parameter  expan-
              sion,  command  substitution, and arithmetic substitution
              occur.

Las ventajas incluyen:

• Permite la ejecución paralela.
• En mi experiencia, esto es mucho más rápido que los archivos temporales. A menos que tenga tantos datos que termine intercambiando, deberían ser órdenes de magnitud más rápidos (solo excluyendo los búferes de almacenamiento en caché HD, que podrían ser tan rápidos para pequeñas cantidades de datos).
• Otros procesos o usuarios no pueden alterar sus datos.

Tienes dos opciones:

1. Usted recupera los datos una vez (en su ejemplo con getInfo) y los almacena en un archivo como lo hace.

2. Obtiene los datos cada vez y no los almacena localmente, es decir, llama getInfocada vez

No veo el problema al crear un archivo temporal para evitar el reprocesamiento / recuperación.

Si le preocupa dejar el archivo temporal en algún lugar, siempre puede usarlo trappara asegurarse de eliminarlo en caso de que el script sea eliminado / interrumpido

trap "rm -f $TMPFILE" EXIT HUP INT QUIT TERM

y úselo mktemppara crear un nombre de archivo único para su archivo temporal.

En lugar de generar un archivo, construya sentencias de asignación de shell y evalúe esa salida.

for SERVICE in $(myfunc); do
    eval $(getInfo $SERVICE |
               sed -n -e '1/\(.*\) *$/SERV_NAME="\1"/p' \
                   -e '/HOSTNAME/s/^[^=]*=\([^=]*\).*/SERV_HOSTNAME="\1"/p' \
                   -e '/Arguments/^[^:]*:\([^:]*\).*/SERV_ARGS="\1"/p')
    print $SERV_NAME $SEP $SERV_HOSTNAME $SED $SERV_ARGS
done

O si solo desea imprimir la información:

for SERVICE in $(myfunc); do
    getInfo $SERVICE | awk -vsep="$SEP" '
        BEGIN{OFS=sep}
        NR == 1 { sub(/ *$/,""); SERV_NAME=$0 }
        /HOSTNAME/ { split($0, HOST, /=/; SERV_HOSTNAME=HOST[2]; }
        /Arguments/ { split($0, ARGS, /:/; SERV_ARGS }
        END { print SERV_NAME, SERV_HOSTNAME, SERV_ARGS }'
done