Início / unix / Perguntas / 439035
Accepted
Timothy Swan
Asked: 2018-04-21 14:31:05 +0800 CST

Trap todos os comandos na função

  • 772

Estou trabalhando com um conjunto de scripts com funções tratadas como somente leitura. As funções são mais do que apenas uma lista de comandos, por exemplo, pode haver loops e alterar diretórios e até chamadas para outras funções:

func() {
    cd folder/
    run command1
    mkdir folder2/ ; cd folder2/
    run command2
}

Por um momento, fingindo que eu poderia mudar os scripts, para mostrar o que eu quero, pode ser assim:

func() {
    cd folder/
    string[0]="command1" ; run command1 |& tee out0.log ; result[0]="$?" ; finished_command_number 0
    mkdir folder2/ ; cd folder2/
    string[1]="command2" ; run command2 |& tee out1.log ; result[1]="$?" ; finished_command_number 1
}

Portanto, para comandos que podem ser canalizados, mas não for cdou loops, desejo armazenar uma string, armazenar o stdout (stderr), armazenar o código de saída e executar outro comando posteriormente. No entanto, não posso adicionar isso, deve ser feito no meu script que está invocando aquele com func().

Para obter apenas a funcionalidade de chamada de pós-comando, tentei copiar a função e executá-la do meu script com um trap foo debug, mas isso não parece se propagar em funções. Não acho que copiar literalmente linha por linha funcionará porque o cde loopsnão pode realmente ser isolado, pois são instruções de controle em vez de comandos de subshell.

Se as strings puderem ser apenas uma função dos próprios comandos, isso ainda será útil.

bash shell-script

2 respostas

  1. Best Answer
    #!/bin/bash
# test.sh
post() {
        echo "post [$BASH_COMMAND] [$?]"
        echo "== $RANDOM =="
}
set -o functrace
trap post debug
func() {
        . check.sh
        tryme |& tee out.txt
}
func

    A saída pode ser filtrada pelas linhas marcadas com random. Eu deveria testar isso mais para ver como funciona com vários processos, mas parece funcionar muito bem com comandos de curta duração. Observe que o código de saída está atrasado em um comando, já que a depuração é aparentemente chamada primeiro.

    #!/bin/bash
# check.sh
tryme() {
        echo "one"
        echo "two"
        mkdir -p hello
        cd hello/
        echo "three"
        false
        echo "four"
}

    ===

    $ bash test.sh 
post [func] [0]
== 22542 ==
post [func] [0]
== 10758 ==
post [. check.sh] [0]
== 9115 ==
post [tryme 2>&1] [0]
== 11979 ==
post [tee out.txt] [0]
== 17814 ==
post [tryme 2>&1] [0]
== 22838 ==
post [echo "one"] [0]
== 5251 ==
one
post [echo "two"] [0]
== 18036 ==
two
post [mkdir -p hello] [0]
== 4247 ==
post [cd hello/] [0]
== 21611 ==
post [echo "three"] [0]
== 24685 ==
three
post [false] [0]
== 8557 ==
post [echo "four"] [1]
== 7565 ==
four
    • 2

  2. Se estou lendo sua pergunta corretamente, você está procurando uma maneira de:

    • Capture stdout e stderr independentemente das saídas de uma chamada de função
    • Preserve o diretório de trabalho atual contra quaisquer alterações feitas durante a execução de uma função

    Isso pode ser feito de forma bastante simples:

    #!/bin/bash
stdout=/path/to/output.std
stderr=/path/to/output.err

somefunc() {
    : Do things
}

( somefunc arg1 arg2 ) >> $stdout 2>> $stderr

    A execução da função em um subshell permitirá que ela faça o que for necessário com relação à alteração do diretório de trabalho e à saída para stdout e stderr normalmente. Quando o subshell sai, o diretório de trabalho do script permanece inalterado e todas as saídas stdout e stderr são capturadas e redirecionadas para seus arquivos de log.

    Adicionar uma matriz (global ou não) na qual capturar códigos de saída de comandos é trivial:

    declare -a exitcodes
( exit 0 )
exitcodes+=( $? )
( exit 2 )
exitcodes+=( $? )
( exit 0 )
exitcodes+=( $? )

echo ${exitcodes[@]}
    • 1

relate perguntas