Bash: controlla la directory per i file rispetto all'elenco di nomi file parziali

Ho un server che riceve un file per client ogni giorno in una directory. I nomi dei file sono costruiti come segue:

uuid_datestring_other-data

Per esempio:

d6f60016-0011-49c4-8fca-e2b3496ad5a7_20160204_023-ERROR

• uuid è un formato standard uuid.
• datestringè l'output di date +%Y%m%d.
• other-data è di lunghezza variabile ma non conterrà mai un carattere di sottolineatura.

Ho un file nel formato:

#
d6f60016-0011-49c4-8fca-e2b3496ad5a7    client1
d5873483-5b98-4895-ab09-9891d80a13da    client2
be0ed6a6-e73a-4f33-b755-47226ff22401    another_client
...

Devo verificare che ogni uuid elencato nel file abbia un file corrispondente nella directory, usando bash.

Sono arrivato così lontano, ma mi sento come se venissi dalla direzione sbagliata usando un'istruzione if, e che ho bisogno di scorrere i file nella directory di origine.

Le variabili source_directory e uuid_list sono state assegnate in precedenza nello script:

# Check the entries in the file list

while read -r uuid name; do
# Ignore comment lines
   [[ $uuid = \#* ]] && continue
   if [[ -f "${source_directory}/${uuid}*" ]]
   then
      echo "File for ${name} has arrived"
   else
      echo "PANIC! - No File for ${name}"
   fi
done < "${uuid_list}"

Come devo verificare che i file nel mio elenco esistano nella directory? Vorrei usare la funzionalità bash per quanto possibile, ma non sono contrario all'utilizzo dei comandi se necessario.

Cammina sui file, crea un array associativo sugli uuidi contenuti nei loro nomi (ho usato l'espansione dei parametri per estrarre l'UUID). Il, leggi l'elenco, controlla l'array associativo per ciascun uuid e segnala se il file è stato registrato o meno.

#!/bin/bash
uuid_list=...

declare -A file_for
for file in *_*_* ; do
    uuid=${file%%_*}
    file_for[$uuid]=1
done

while read -r uuid name ; do
    [[ $uuid = \#* ]] && continue
    if [[ ${file_for[$uuid]} ]] ; then
        echo "File for $name has arrived."
    else
        echo "File for $name missing!"
    fi
done < "$uuid_list"

Ecco un approccio più "schivo" e conciso:

#!/bin/bash

## Read the UUIDs into the array 'uuids'. Using awk
## lets us both skip comments and only keep the UUID
mapfile -t uuids < <(awk '!/^\s*#/{print $1}' uuids.txt)

## Iterate over each UUID
for uuid in ${uuids[@]}; do
        ## Set the special array $_ (the positional parameters: $1, $2 etc)
        ## to the glob matching the UUID. This will be all file/directory
        ## names that start with this UUID.
        set -- "${source_directory}"/"${uuid}"*
        ## If no files matched the glob, no file named $1 will exist
        [[ -e "$1" ]] && echo "YES : $1" || echo  "PANIC $uuid" 
done

Nota che sebbene quanto sopra sia carino e funzionerà bene per alcuni file, la sua velocità dipende dal numero di UUID e sarà molto lento se devi elaborarne molti. In tal caso, utilizzare la soluzione di @ choroba o, per qualcosa di veramente veloce, evitare la shell e chiamare perl:

#!/bin/bash

source_directory="."
perl -lne 'BEGIN{
            opendir(D,"'"$source_directory"'"); 
            foreach(readdir(D)){ /((.+?)_.*)/; $f{$2}=$1; }
           } 
           s/\s.*//; $f{$_} ? print "YES: $f{$_}" : print "PANIC: $_"' uuids.txt

Solo per illustrare le differenze temporali, ho testato il mio approccio bash, quello di choroba e il mio perl su un file con 20000 UUID di cui 18001 aveva un nome file corrispondente. Si noti che ogni test è stato eseguito reindirizzando l'output dello script su /dev/null.

1. Il mio bash (~ 3.5 min)

   real   3m39.775s
   user   1m26.083s
   sys    2m13.400s

2. Choroba's (bash, ~ 0.7 sec)

   real   0m0.732s
   user   0m0.697s
   sys    0m0.037s

3. Il mio perl (~ 0.1 sec):

   real   0m0.100s
   user   0m0.093s
   sys    0m0.013s

Questo è puro Bash (cioè nessun comando esterno), ed è l'approccio più coincidente a cui riesco a pensare.

Ma per quanto riguarda le prestazioni non è molto meglio di quello che hai attualmente.

Leggerà ogni riga da path/to/file; per ogni riga, memorizzerà il primo campo $uuide stampa un messaggio se nonpath/to/directory/$uuid* viene trovato un file corrispondente al modello :

#! /bin/bash
[ -z "$2" ] && printf 'Not enough arguments.\n' && exit

while read uuid; do
    [ ! -f "$2/$uuid"* ] && printf '%s missing in %s\n' "$uuid" "$2"
done <"$1"

Chiamalo con path/to/script path/to/file path/to/directory.

Output di esempio utilizzando il file di input di esempio nella domanda in una gerarchia di directory di test contenente il file di esempio nella domanda:

% tree
.
├── path
│   └── to
│       ├── directory
│       │   └── d6f60016-0011-49c4-8fca-e2b3496ad5a7_20160204_023-ERROR
│       └── file
└── script.sh

3 directories, 3 files
% ./script.sh path/to/file path/to/directory
d5873483-5b98-4895-ab09-9891d80a13da* missing in path/to/directory
be0ed6a6-e73a-4f33-b755-47226ff22401* missing in path/to/directory

unset IFS
set -f
set +f -- $(<uuid_file)
while  [ "${1+:}" ]
do     : < "$source_directory/$1"*  &&
       printf 'File for %s has arrived.\n' "$2"
       shift 2
done

L'idea qui non è quella di preoccuparsi di segnalare errori che la shell segnalerà per te. Se provi ad <aprire un file che non esiste, la tua shell si lamenterà. In effetti, anteporrà il tuo script $0e il numero di riga su cui si è verificato l'errore all'output dell'errore quando lo fa ... Queste sono buone informazioni che sono già fornite di default, quindi non preoccuparti.

Inoltre non è necessario prendere il file riga per riga in questo modo - può essere terribilmente lento. Questo espande il tutto in un singolo colpo in una serie di argomenti delimitati da spazi bianchi e ne gestisce due alla volta. Se i tuoi dati sono coerenti con il tuo esempio, $1saranno sempre i tuoi uuidi e $2saranno tuoi $name. Se bashpuoi aprire una partita al tuo uuid - e esiste solo una di queste partite - allora printfsuccede. Altrimenti no e la shell scrive la diagnostica a stderr sul perché.

Il modo in cui mi avvicinerei è quello di ottenere prima gli uuidi dal file, quindi utilizzare find

awk '{print $1}' listfile.txt  | while read fileName;do find /etc -name "$fileName*" -printf "%p FOUND\n" 2> /dev/null;done

Per leggibilità,

awk '{print $1}' listfile.txt  | \
    while read fileName;do \
    find /etc -name "$fileName*" -printf "%p FOUND\n" 2> /dev/null;
    done

Esempio con un elenco di file in /etc/, cercando i nomi dei file passwd, group, fstab e THISDOESNTEXIST.

$ awk '{print $1}' listfile.txt  | while read fileName;do find /etc -name "$fileName*" -printf "%p FOUND\n" 2> /dev/null; done
/etc/pam.d/passwd FOUND
/etc/cron.daily/passwd FOUND
/etc/passwd FOUND
/etc/group FOUND
/etc/iproute2/group FOUND
/etc/fstab FOUND

Dal momento che hai menzionato la directory è piatta, è possibile utilizzare l' -printf "%f\n"opzione per stampare solo il nome file stesso

Ciò che non fa è elencare i file mancanti. findIl piccolo svantaggio è che non ti dice se non trova un file, solo quando corrisponde a qualcosa. Ciò che si potrebbe fare, tuttavia, è controllare l'output: se l'output è vuoto, allora manca un file

awk '{print $1}' listfile.txt  | while read fileName;do RESULT="$(find /etc -name "$fileName*" -printf "%p\n" 2> /dev/null )"; [ -z "$RESULT"  ] && echo "$fileName not found" || echo "$fileName found"  ;done

Più leggibile:

awk '{print $1}' listfile.txt  | \
   while read fileName;do \
   RESULT="$(find /etc -name "$fileName*" -printf "%p\n" 2> /dev/null )"; \
   [ -z "$RESULT"  ] && echo "$fileName not found" || \
   echo "$fileName found"  
   done

Ed ecco come si comporta come un piccolo script:

skolodya@ubuntu:$ ./listfiles.sh                                               
passwd found
group found
fstab found
THISDONTEXIST not found

skolodya@ubuntu:$ cat listfiles.sh                                             
#!/bin/bash
awk '{print $1}' listfile.txt  | \
   while read fileName;do \
   RESULT="$(find /etc -name "$fileName*" -printf "%p\n" 2> /dev/null )"; \
   [ -z "$RESULT"  ] && echo "$fileName not found" || \
   echo "$fileName found"  
   done

Si potrebbe usare statcome alternativa, dal momento che è una directory piatta, ma il codice seguente non funzionerà in modo ricorsivo per le sottodirectory se si decide di aggiungere quelle:

$ awk '{print $1}' listfile.txt  | while read fileName;do  stat /etc/"$fileName"* 1> /dev/null ;done        
stat: cannot stat ‘/etc/THISDONTEXIST*’: No such file or directory

Se prendiamo l' statidea e la eseguiamo, potremmo usare il codice di uscita di stat come indicazione dell'esistenza o meno di un file. In effetti, vogliamo fare questo:

$ awk '{print $1}' listfile.txt  | while read fileName;do  if stat /etc/"$fileName"* &> /dev/null;then echo "$fileName found"; else echo "$fileName NOT found"; fi ;done

Esecuzione di esempio:

skolodya@ubuntu:$ awk '{print $1}' listfile.txt  | \                                                         
> while read FILE; do                                                                                        
> if stat /etc/"$FILE" &> /dev/null  ;then                                                                   
> echo "$FILE found"                                                                                         
> else echo "$FILE NOT found"                                                                                
> fi                                                                                                         
> done
passwd found
group found
fstab found
THISDONTEXIST NOT found