Bash - Vérifier le répertoire des fichiers par rapport à la liste des noms de fichiers partiels

J'ai un serveur qui reçoit chaque jour un fichier par client dans un répertoire. Les noms de fichiers sont construits comme suit:

uuid_datestring_other-data

Par exemple:

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

• uuid est un uuid au format standard.
• datestringest la sortie de date +%Y%m%d.
• other-data est de longueur variable mais ne contiendra jamais de soulignement.

J'ai un fichier au format:

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

Je dois vérifier que chaque uuid répertorié dans le fichier a un fichier correspondant dans le répertoire, en utilisant bash.

J'en suis là, mais j'ai l'impression de venir dans la mauvaise direction en utilisant une instruction if, et que je dois parcourir les fichiers dans le répertoire source.

Les variables source_directory et uuid_list ont été assignées plus tôt dans le 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}"

Comment vérifier que les fichiers de ma liste existent dans le répertoire? J'aimerais utiliser la fonctionnalité bash autant que possible, mais je ne suis pas contre l'utilisation de commandes si besoin est.

Parcourez les fichiers, créez un tableau associatif sur les uuids contenus dans leurs noms (j'ai utilisé l'expansion des paramètres pour extraire l'uuid). Lisez la liste, vérifiez le tableau associatif pour chaque uuid et indiquez si le fichier a été enregistré ou non.

#!/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"

Voici une approche plus "timide" et concise:

#!/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

Notez que bien que ce qui précède soit joli et fonctionnera bien pour quelques fichiers, sa vitesse dépend du nombre d'UUID et sera très lente si vous devez en traiter plusieurs. Si tel est le cas, utilisez la solution de @ choroba ou, pour quelque chose de vraiment rapide, évitez le shell et appelez 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

Juste pour illustrer les différences de temps, j'ai testé mon approche bash, choroba et mon perl sur un fichier avec 20000 UUID dont 18001 avaient un nom de fichier correspondant. Notez que chaque test a été exécuté en redirigeant la sortie du script vers /dev/null.

1. Mon coup (~ 3,5 min)

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

2. Choroba (bash, ~ 0,7 sec)

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

3. Mon perl (~ 0,1 sec):

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

C'est du pur Bash (c'est-à-dire pas de commandes externes), et c'est l'approche la plus coïncidente à laquelle je puisse penser.

Mais en termes de performances, ce n'est vraiment pas beaucoup mieux que ce que vous avez actuellement.

Il lira chaque ligne de path/to/file; pour chaque ligne, il stockera le premier champ $uuidet affichera un message si aucun fichier correspondant au modèle path/to/directory/$uuid*n'est trouvé:

#! /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"

Appelez-le avec path/to/script path/to/file path/to/directory.

Exemple de sortie à l'aide de l'exemple de fichier d'entrée dans la question sur une hiérarchie de répertoires de test contenant l'exemple de fichier dans la question:

% 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'idée ici n'est pas de s'inquiéter des erreurs de rapport que le shell rapportera pour vous. Si vous essayez d' <ouvrir un fichier qui n'existe pas, votre shell se plaindra. En fait, il ajoutera votre script $0et le numéro de ligne sur lequel l'erreur s'est produite à la sortie d'erreur quand c'est le cas ... Ce sont de bonnes informations qui sont déjà fournies par défaut - alors ne vous embêtez pas.

Vous n'avez pas non plus besoin de prendre le fichier ligne par ligne comme ça - cela peut être terriblement lent. Cela étend le tout en une seule prise de vue à un tableau d'arguments délimité par des espaces blancs et en gère deux à la fois. Si vos données sont conformes à votre exemple, elles $1seront toujours votre uuid et $2seront les vôtres $name. Si vous bashpouvez ouvrir une correspondance avec votre uuid - et qu'une seule de ces correspondances existe - alors printfcela se produit. Sinon, ce n'est pas le cas et le shell écrit des diagnostics à stderr pour savoir pourquoi.

La façon dont je l'aborderais est d'obtenir d'abord les uuids du fichier, puis d'utiliser find

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

Pour la lisibilité,

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

Exemple avec une liste de fichiers dans /etc/, recherchant les noms de fichiers passwd, group, fstab et 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

Puisque vous avez mentionné que le répertoire est plat, vous pouvez utiliser l' -printf "%f\n"option pour simplement imprimer le nom de fichier lui-même

Ce que cela ne fait pas, c'est de répertorier les fichiers manquants. findLe petit inconvénient est qu'il ne vous dit pas s'il ne trouve pas de fichier, seulement lorsqu'il correspond à quelque chose. Ce que l'on pourrait faire, cependant, est de vérifier la sortie - si la sortie est vide, alors nous avons un fichier manquant

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

Plus lisible:

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

Et voici comment il fonctionne comme un petit 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

On pourrait utiliser statcomme alternative, car c'est un répertoire plat, mais le code ci-dessous ne fonctionnera pas récursivement pour les sous-répertoires si vous décidez de les ajouter:

$ 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

Si nous prenons l' statidée et l'exécutons, nous pourrions utiliser le code de sortie de stat pour indiquer si un fichier existe ou non. Effectivement, nous voulons faire ceci:

$ 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

Exemple d'exécution:

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