Início / unix / Perguntas / 769898
Accepted
Olivier Dulac
Asked: 2024-02-23 00:14:17 +0800 CST

awk (e gawk): como evitar erros fatais quando 1 dos N arquivos de entrada está ilegível

  • 772

caso de teste: (com um usuário não root, pois o root desconsideraria a permissão 000...)

#in a clean directory:
[ -f file_1 ] && chmod 600 file_? # for repeat tests...
for i in file_1 file_2 file_3; do
    printf 'A\nB\n' > "$i" 
    # we need at least 1 char : awk/gawk silently skips empty files...
done
chmod 000 file_2
awk '(FNR==1) { print FILENAME }' file_? 
  # tried with : regular (old unixes) awk on AIX. and gawk on Linux.
  # the fatal "permission denied" on file_2 stops [g]awk.

Existe uma maneira de detectar esse erro fatal e continuar com os próximos arquivos?

(caso contrário, acho bastante preocupante: usar o awk em vários arquivos não garante o processamento de todos eles, pois ele será encerrado fatalmente se algum deles estiver ilegível)

Por favor, se possível: responda

  • para awk normal,
  • e para ficar de boca aberta
  • e quaisquer outras versões relevantes do awk? (não é? etc)
awk

2 respostas

  1. Com GAWK:

    gawk 'BEGINFILE { if (ERRNO) nextfile } (FNR==1) { print FILENAME }' file_?

    No BEGINFILEbloco, ERRNOfica vazio se o arquivo foi aberto com sucesso e nextfilepode ser usado para pular para o próximo e evitar o resgate com erro.

    Não acho que isso seja compatível com outras implementações do AWK.

    Portavelmente, você pode iterar todos os argumentos, verificar se eles apontam para um arquivo ilegível e, em caso afirmativo, removê-los dos argumentos antes que o AWK comece a processá-los; o manual GAWK tem um exemplo de implementação . No entanto, isso é atrevido, pois um arquivo verificado usando esse loop pode se tornar ilegível (ou vice-versa) antes que o AWK comece a processá-lo.

    • 9
  2. Best Answer

    Como @StephenKitt e @ilkkachu já apontaram, o manual do gawk contém algum código que removerá arquivos ilegíveis da ARGV[]seção BEGIN, mas que tem uma condição de corrida entre o momento em que o arquivo é testado e quando o awk realmente tenta ler seu conteúdo, o que pode ser muito mais tarde se os arquivos anteriores forem grandes.

    Eu usaria o script na resposta de @StephenKitt se você tiver o gawk ou o script no manual do gawk, caso contrário, a menos que você ache que pode ter esse problema de condição de corrida, pois o script do manual do gawk é mais claro, mais breve, mais simples, mais eficiente, etc. do que o que está abaixo e não requer um arquivo temporário e variáveis ​​globais, mas para aqueles que estão preocupados com essa condição de corrida - aqui está um script mais complicado que funcionará em qualquer awk e depende da criação de um arquivo temporário para abrir imediatamente antes de tentar para abrir qualquer arquivo real e nesse ponto testar se o próximo arquivo real é legível ou não.

    $ cat skip.awk
function addTmp(        cmd, oArgv, i, j) {
    cmd = "mktemp"
    cmd | getline TmpChkFile
    close(cmd)

    if ( TmpChkFile != "" ) {
        print "" > TmpChkFile
        close(TmpChkFile)

        for (i in ARGV) {
            oArgv[i] = ARGV[i]
        }
        oArgc = ARGC

        ARGC = 1
        for (i = 1; i < oArgc; i++) {
            if ( ! (oArgv[i] ~ /^[a-zA-Z_][a-zA-Z0-9_]*=.*/ \
                    || oArgv[i] == "-" || oArgv[i] == "/dev/stdin") ) {
                # not assignment or standard input so a file name
                ARGV[ARGC] = TmpChkFile
                ArgFileNames[++j] = oArgv[i]
                ArgFileIndices[j] = ++ARGC
            }
            ARGV[ARGC++] = oArgv[i]
        }
    }
}

function rmvTmp() {
    system("rm -f \047" TmpChkFile "\047")
}

function chkTmp(        stderr, line) {
    if ( (FNR == 1) && (FILENAME == TmpChkFile) ) {
        ++TmpFileNr
        if ( (getline line < ArgFileNames[TmpFileNr]) < 0 ) {
            stderr = "cat>&2"
            printf "Warning: skipping unreadable file \"%s\"\n", ArgFileNames[TmpFileNr] | stderr
            close(stderr)
            delete ARGV[ArgFileIndices[TmpFileNr]]
        }
        close(ArgFileNames[TmpFileNr])
        next
    }
}

BEGIN { addTmp() }
END { rmvTmp() }
{ chkTmp() }

    Se o seu awk suportar múltiplos -fargumentos (por exemplo, conforme exigido pelo POSIX ) ou qualquer outra forma de executar vários scripts de uma vez (por exemplo, GNU awk has @include), então você pode usar esse método para incluir o acima junto com o seu script real (caso contrário, copie/cole o acima no mesmo arquivo), por exemplo, se você tiver um script como:

    $ cat tst.awk
FNR == 1 { print FILENAME, $0 }

    e arquivos como:

    $ ls file_{1..3}
ls: cannot access 'file_2': No such file or directory
file_1  file_3

    então, com qualquer awk POSIX (e a maioria, senão todos, outros) você pode fazer:

    $ awk -f skip.awk -f tst.awk file_{1..3}
file_1 A
Warning: skipping unreadable file "file_2"
file_3 C

    A maior parte do trabalho acima é feito BEGINchamando uma vez antes do primeiro arquivo de entrada ser aberto para garantir que um arquivo temporário legível exista ARGV[]imediatamente antes de cada arquivo de entrada real, então chkTmp()é chamado para cada linha de entrada, mas só faz algo quando é o primeiro (e única) linha do arquivo temporário e essa coisa é tentar abrir o arquivo de entrada real que vem depois dele em ARGV[]. Depois ENDé só remover o arquivo temporário. Portanto, a sobrecarga extra real é a chamada chkTmp()e o teste FNR==1para cada linha de entrada.

    Estou criando um arquivo temporário em vez de usar um arquivo existente porque não há nenhum arquivo com existência garantida em todas as caixas Unix e, mesmo se houvesse, teria que ter exatamente 1 linha para evitar adicionar sobrecarga extra de chkTmp()ter que ler todas as linhas desse arquivo, já que nem todos os awks suportam nextfile(ou poderíamos chamar isso em vez de nextinside chkTmp()).

    • 3

relate perguntas