Leia os caminhos no stdin e gere um novo shell interativo para cada linha

Considere um comando que pesquisa em todo o diretório inicial um arquivo ou diretório com as permissões erradas:

$ find $HOME -perm 777

Este é apenas um exemplo; o comando pode estar listando links simbólicos quebrados:

$ find $HOME -xtype l

ou listando links simbólicos longos:

$ symlinks -s -r $HOME

ou qualquer número de outros comandos caros que enviam caminhos delimitados por nova linha para stdout.

Agora, eu poderia reunir os resultados em um pager como este:

$ find $HOME -perm 777 | less

e, em seguida, cdpara os diretórios relevantes em um terminal virtual diferente. Mas eu prefiro ter um script que abra um novo shell interativo para cada linha de saída, assim:

$ find $HOME -perm 777 | visit-paths.sh

Dessa forma, posso, por exemplo, inspecionar cada arquivo ou diretório, verificar o carimbo de data/hora, decidir se preciso alterar as permissões ou excluir arquivos, etc.

É possível com um script bash que lê caminhos de um arquivo ou de stdin , assim:

#! /usr/bin/env bash

set -e

declare -A ALREADY_SEEN
while IFS='' read -u 10 -r line || test -n "$line"
do
    if test -d "$line"
    then
        VISIT_DIR="$line"
    elif test -f "$line"
    then
        VISIT_DIR="$(dirname "$line")"
    else
        printf "Warning: path does not exist: '%s'\n" "$line" >&2
        continue
    fi
    if test "${ALREADY_SEEN[$VISIT_DIR]}" != '1'
    then
        ( cd "$VISIT_DIR" && $SHELL -i </dev/tty )
        ALREADY_SEEN[${VISIT_DIR}]=1
        continue
    else
        # Same as last time, skip it.
        continue
    fi
done 10< "${*:-/dev/stdin}"

Isso tem alguns pontos positivos, como:

• O script abre um novo shell assim que uma nova linha de saída aparece no stdin. Isso significa que não preciso esperar que o comando slow termine completamente antes de começar a fazer as coisas.

• O comando slow continua sendo executado em segundo plano enquanto estou fazendo coisas no shell recém-gerado, então o próximo caminho está potencialmente pronto para ser visitado quando eu terminar.

• Eu posso sair do loop mais cedo, se necessário, com, por exemplo false; exit, ou apenas Ctrl-C Ctrl-D.

• O script lida com nomes de arquivos e diretórios.

• O script evita navegar para o mesmo diretório duas vezes seguidas. (Obrigado a @MichaelHomer por explicar como fazer isso com arrays associativos.)

No entanto, há um problema com este script:

• Todo o pipeline é encerrado se o último comando tiver um status diferente de zero, o que é útil para sair antecipadamente, mas em geral requer verificação a $?cada vez para evitar uma saída antecipada acidental.

Para tentar resolver esse problema, escrevi um script Python:

#! /usr/bin/env python3

import argparse
import logging
import os
import subprocess
import sys

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Visit files from file or stdin.'
    )
    parser.add_argument(
        '-v',
        '--verbose',
        help='More verbose logging',
        dest="loglevel",
        default=logging.WARNING,
        action="store_const",
        const=logging.INFO,
    )
    parser.add_argument(
        '-d',
        '--debug',
        help='Enable debugging logs',
        action="store_const",
        dest="loglevel",
        const=logging.DEBUG,
    )
    parser.add_argument(
        'infile',
        nargs='?',
        type=argparse.FileType('r'),
        default=sys.stdin,
        help='Input file (or stdin)',
    )
    args = parser.parse_args()
    logging.basicConfig(level=args.loglevel)
    shell_bin = os.environ['SHELL']
    logging.debug("SHELL = '{}'".format(shell_bin))
    already_visited = set()
    n_visits = 0
    n_skipped = 0
    for i, line in enumerate(args.infile):
        visit_dir = None
        candidate = line.rstrip()
        logging.debug("candidate = '{}'".format(candidate))
        if os.path.isdir(candidate):
            visit_dir = candidate
        elif os.path.isfile(candidate):
            visit_dir = os.path.dirname(candidate)
        else:
            logging.warning("does not exist: '{}'".format(candidate))
            n_skipped +=1
            continue
        if visit_dir is not None:
            real_dir = os.path.realpath(visit_dir)
        else:
            # Should not happen.
            logging.warning("could not determine directory for path: '{}'".format(candidate))
            n_skipped +=1
            continue
        if visit_dir in already_visited:
            logging.info("already visited: '{}'".format(visit_dir))
            n_skipped +=1
            continue
        elif real_dir in already_visited:
            logging.info("already visited: '{}' -> '{}'".format(visit_dir, real_dir))
            n_skipped +=1
            continue
        if i != 0:
            try :
                response = input("#{}. Continue? (y/n) ".format(n_visits + 1))
            except EOFError:
                sys.stdout.write('\n')
                break
            if response in ["n", "no"]:
                break
        logging.info("spawning '{}' in '{}'".format(shell_bin, visit_dir))
        run_args = [shell_bin, "-i"]
        subprocess.call(run_args, cwd=visit_dir, stdin=open('/dev/tty'))
        already_visited.add(visit_dir)
        already_visited.add(real_dir)
        n_visits +=1

    logging.info("# paths received: {}".format(i + 1))
    logging.info("distinct directories visited: {}".format(n_visits))
    logging.info("paths skipped: {}".format(n_skipped))

No entanto, estou tendo alguns problemas com as respostas ao Continue? (y/n)prompt sendo passado para o shell que é gerado, causando erros como y: command not found. Suspeito que o problema esteja nesta linha:

subprocess.call(run_args, cwd=visit_dir, stdin=open('/dev/tty'))

Preciso fazer algo diferente com o stdinao usar subprocess.call?

Como alternativa, existe uma ferramenta amplamente disponível que torna os dois scripts redundantes da qual eu não ouvi falar?