Programmation shell, évitant les fichiers temporaires

J'écris souvent des scripts shell KSH qui suivent le même modèle:

• (1) récupérer la sortie d'une ou plusieurs commandes
• (2) formatez-le en utilisant grep | cut | awk | sed et imprimez-le à l'écran ou dans un fichier

Pour ce faire, je stocke souvent la sortie de (1) dans un fichier temporaire, puis je fais le formatage en (2) sur ce fichier.

Prenez ce code par exemple:

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

Existe-t-il un moyen, en utilisant des canaux, des redirections et autres joyeusetés, d'éviter d'écrire un fichier sur le disque à chaque fois?

Si cela aide, j'utilise la version ksh M-11/16 / 88i

Votre code ressemble à un exemple entièrement justifié d'utilisation de fichiers temporaires pour moi. Je resterais: respectez cette approche. La seule chose qui doit vraiment être modifiée est la façon dont vous créez le fichier temporaire. Utilisez quelque chose comme

 TMP=$(tempfile)

ou

 TMP=$(mktemp)

ou au moins

 TMP=/tmp/myscript_$$

De cette façon, vous ne laisserez pas le nom être facilement prédit (sécurité) et éliminerez les interférences de règles entre plusieurs instances du script s'exécutant en même temps.

Vous pouvez utiliser une 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.

Les avantages comprennent:

• Permet l'exécution parallèle.
• D'après mon expérience, c'est beaucoup plus rapide que les fichiers temporaires. Sauf si vous avez tellement de données que vous finissez par les échanger, cela devrait être des ordres de grandeur plus rapides (sauf les tampons de mise en cache HD, qui peuvent être à peu près aussi rapides pour de petites quantités de données).
• D'autres processus ou utilisateurs ne peuvent pas gâcher vos données.

Vous avez deux options:

1. Vous récupérez les données une fois (dans votre exemple avec getInfo) et les stockez dans un fichier comme vous le faites.

2. Vous récupérez les données à chaque fois et ne les stockez pas localement, c'est-à-dire que vous appelez à getInfochaque fois

Je ne vois pas le problème de la création d'un fichier temporaire pour éviter le retraitement / la récupération.

Si vous craignez de laisser le fichier temporaire quelque part, vous pouvez toujours l'utiliser trappour être sûr de le supprimer au cas où le script serait tué / interrompu

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

et utilisez mktemppour créer un nom de fichier unique pour votre fichier temporaire.

Au lieu de générer un fichier, construisez des instructions d'affectation de shell et évaluez cette sortie.

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

Ou si vous souhaitez simplement imprimer les informations:

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