Programmazione della shell, evitando tempfile

Scrivo spesso script di shell KSH che seguono lo stesso schema:

• (1) recupera l'output da uno o più comandi
• (2) formattalo usando grep | cut | awk | sed e stampalo sullo schermo o su un file

Per fare ciò, spesso memorizzo l'output di (1) in un file temporaneo, quindi eseguo la formattazione in (2) su quel file.

Prendi quel codice per esempio:

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

C'è un modo, usando pipe, reindirizzamenti e quant'altro, per evitare di scrivere un file su disco ogni volta?

Se aiuta, sto usando la versione ksh M-11/16 / 88i

Il tuo codice sembra un esempio del tutto giustificato dell'uso dei tempfile per me. Starei: attenersi a questo approccio. L'unica cosa che deve davvero essere cambiata è il modo in cui crei il tempfile. Usa qualcosa di simile

 TMP=$(tempfile)

o

 TMP=$(mktemp)

o quantomeno

 TMP=/tmp/myscript_$$

In questo modo non si lascerà che il nome sia facilmente previsto (sicurezza) e si eliminino le interferenze delle regole tra più istanze dello script in esecuzione contemporaneamente.

È possibile utilizzare una variabile:

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

Da 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.

I vantaggi includono:

• Abilita l'esecuzione parallela.
• Nella mia esperienza questo è molto più veloce dei file temporanei. A meno che non si disponga di così tanti dati da finire con lo scambio, gli ordini di grandezza dovrebbero essere più veloci (escludendo solo i buffer di memorizzazione nella cache HD, che potrebbero essere altrettanto veloci per piccole quantità di dati).
• Altri processi o utenti non possono incasinare i tuoi dati.

Hai due opzioni:

1. Recuperi i dati una volta (nel tuo esempio con getInfo) e li memorizzi in un file mentre lo fai.

2. Prendi i dati ogni volta e non li memorizzi localmente, vale a dire che chiami getInfoogni volta

Non vedo il problema nella creazione di un file temporaneo per evitare il rielaborazione / recupero.

Se sei preoccupato di lasciare il file temporaneo da qualche parte, puoi sempre utilizzare trapper essere sicuro di eliminarlo nel caso in cui lo script venga ucciso / interrotto

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

e utilizzare mktempper creare un nome file univoco per il file temporaneo.

Invece di generare un file, costruisci istruzioni di assegnazione della shell e valuta quell'output.

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 se vuoi solo stampare le informazioni:

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