Programação de shell, evitando tempfiles

Costumo escrever scripts de shell KSH que seguem o mesmo padrão:

• (1) recuperar a saída de um ou mais comandos
• (2) formate-o usando grep | cut | awk | sed e imprima-o na tela ou em um arquivo

Para fazer isso, costumo armazenar a saída de (1) em um arquivo temporário e, em seguida, faço a formatação em (2) nesse arquivo.

Tome esse código, por exemplo:

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 uma maneira, usando pipes, redirecionamentos e outras coisas, para evitar gravar um arquivo no disco a cada vez?

Se ajudar, estou usando a versão ksh M-11/16 / 88i

Seu código parece um exemplo inteiramente justificado de usar tempfiles para mim. Eu ficaria: fique com essa abordagem. A única coisa que realmente precisa ser alterada é a maneira como você cria o arquivo temporário. Use algo como

 TMP=$(tempfile)

ou

 TMP=$(mktemp)

ou pelo menos

 TMP=/tmp/myscript_$$

Dessa forma, você não permitirá que o nome seja facilmente previsto (segurança) e exclua a interferência entre várias instâncias do script em execução ao mesmo tempo.

Você poderia usar uma variável:

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.

As vantagens incluem:

• Habilita a execução paralela.
• Na minha experiência, isso é muito mais rápido que os arquivos temporários. A menos que você tenha tantos dados que você acaba trocando, eles devem ter ordens de magnitude mais rápidas (exceto os buffers de cache em HD, que podem ser tão rápidos quanto pequenas quantidades de dados).
• Outros processos ou usuários não podem atrapalhar seus dados.

Você tem duas opções:

1. Você recupera os dados uma vez (no seu exemplo com getInfo) e os armazena em um arquivo como faz.

2. Você busca os dados a cada vez e não os armazena localmente, ou seja, liga getInfosempre

Não vejo o problema ao criar um arquivo temporário para evitar o reprocessamento / nova busca.

Se você estiver preocupado em deixar o arquivo temporário em algum lugar, sempre poderá trapexcluí-lo, caso o script seja interrompido / interrompido

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

e use mktemppara criar um nome de arquivo exclusivo para seu arquivo temporário.

Em vez de gerar um arquivo, construa instruções de atribuição de shell e avalie essa saída.

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 se você quiser apenas imprimir as informações:

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