I file "sovrascritti", lo spazio ancora occupato, sono persi?

Così stupido impaziente, ho usato il seguente script sul mio server 19.04 nel tentativo di spostare un gruppo di file video in cartelle con prefissi:

dirs=(A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)
shopt -s nocasematch

for file in *
do
    for dir in "${dirs[@]}"
    do

     if [ -d "$file" ]; then
      echo 'this is a dir, skipping'
      break
     else
      if [[ $file =~ ^[$dir] ]]; then
       echo "----> $file moves into -> $dir <----"
       mv "$file" "$dir"
       break
      fi
     fi
  done
done

Non ho idea di dove sia andato storto, ma invece di spostare i file in cartelle è andato su un output singolare .. quindi:

----> a1.ts moves into -> A <----
----> a2.ts moves into -> A <----
----> a3.ts moves into -> A <----
----> a4.ts moves into -> A <----
----> a5.ts moves into -> A <----
----> c1.ts moves into -> C <----
----> c2.ts moves into -> C <----
----> c3.ts moves into -> C <----
----> c4.ts moves into -> C <----
----> c5.ts moves into -> C <----

Per fortuna ho interrotto il processo (CTRL + C) non appena ho notato che non stava andando come previsto e non ho attraversato l'intera cartella.

Quindi ora ho quei file Ae C, che sono meno di un GB, e a quanto pare sono un SINGOLO video.

Ci sono 50 GB non contabilizzati nell'uso totale del disco della cartella stessa, ma lo spazio su disco complessivo del computer è rimasto lo stesso. Mi fai pensare che i file non vengano cancellati?

Qualsiasi aiuto apprezzato, grazie :)

Modifica: i file in realtà sono spariti, rimane solo l'ultimo file da scrivere, è bastato un po 'di tempo per l'aggiornamento delle informazioni sull'uso del disco .. morale della storia, esegui i tuoi script su file finti prima!

Penso che questo sia il problema: avresti dovuto creare le directory A, B, C ... Z. Se così fosse, il mvcomando avrebbe dovuto spostare i file in quelle directory.

In caso contrario, il mvcomando sposta i file in file con quei nomi, A, B, C ... e penso che sia quello che hai fatto.

Per rendere più sicuro lo shellscript, dovresti farlo creare le directory (se non sono già presenti) prima di iniziare lo spostamento.

dirs=(A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)

for dir in "${dirs[@]}"
do
 mkdir -p $dir
done

Se vuoi che le cose diventino ancora più sicure, puoi anche usare mvcon l' -iopzione

   -i, --interactive
          prompt before overwrite

@Sudodus ha già spiegato cosa è andato storto, ma ecco una versione più semplice del tuo script per la prossima volta:

for letter in {a..z}; do 
    dir=${letter^}
    mkdir -p -- "$dir" 
    mv -- "$letter"* "${letter^^}"* "$dir"/
done

Spiegazione

• for letter in {a..z}; do: si {a..z}espande in tutte le lettere minuscole tra ae z:

  $ echo {a..z}
  a b c d e f g h i j k l m n o p q r s t u v w x y z

  Quindi questo ripeterà tutte le lettere minuscole, salvandole ognuna come $letter.

• dir=${letter^}: la sintassi ${var^^}restituisce il contenuto della variabile $varcon il primo carattere in maiuscolo (poiché questo ha solo un carattere, questo è tutto ciò di cui abbiamo bisogno). Quindi, se $letterè a, allora ${letter^^}è Ae quindi $dirsarà la versione maiuscola dell'attuale $letter.

• mkdir -p -- "$dir": crea la directory. Se esiste già, non fare nulla ( -p). La -- significa la fine delle opzioni , ed è utile per la protezione contro i nomi che iniziano con -.
• mv -- "$letter"* "${letter^}"* "$dir" : sposta ogni file (o directory) sulla destinazione pertinente.

Il problema è che sposta anche le directory che potresti avere. Non sposterà le directory di destinazione, perché o non esistono ancora, o proverai a spostarle in se stesse, ma verranno spostate tutte le directory esistenti che non sono la directory di destinazione.

Se questo è un problema, dovrai fare qualcosa del genere:

for file in *; do 
    if [[ ! -d "$file" ]]; then 
        letter="${file:0:1}"
        dir="${letter^}"
        mkdir -p -- "$dir"
        mv -- "$file" "$dir"/
    fi
done

Invece di controllare ogni file con un array di dizionari che crea molta iterazione, puoi confrontare i file con i pattern.

Ordinamento molto semplice:

#!/bin/bash

videos=./videos
sorted=./sorted

# sort types link,move.
sort_type=link

find "$videos" -maxdepth 1 -type f \
   \( -name '*.avi' -o -name '*.mkv' -o -name '*.mp4' \) -print0 |

while IFS= read -r -d ''; do

    b=$(basename "$REPLY")
    c=${b::1}

    case $c in
        [a-zA-Z]) label=${c^} ;; [0-9]) label="0-9" ;; *) label="_" ;;
    esac

    [[ ! -d "$sorted/$label" ]] && mkdir -p "$sorted/$label"

    if [[ -L $sorted/$label/$b ]] || [[ -e $sorted/$label/$b ]]; then
        echo "File/link: '$b' exists, skipping."
        continue
    fi

    case $sort_type in
        link)
            ln -rfst "$sorted/$label" -- "$REPLY"
            ;;
        move)
               mv -t "$sorted/$label" -- "$REPLY"
            ;;
    esac
done

Salvaguarda nel tuo .bashrc:

alias mv="mv -n --backup=numbered"

Per la cronaca, alcuni modi per impedire la mvsovrascrittura di file esistenti:

• Se vuoi spostarti in una directory, aggiungi una barra alla destinazione, ovvero usa mv "$file" "$dir"/invece di mv "$file" "$dir". Se $dirnon esiste o non è una directory, mvsi lamenterà:

  $ touch a
  $ mv a z/
  mv: cannot move 'a' to 'z/': Not a directory
  $ touch z
  $ mv a z/
  mv: failed to access 'z/': Not a directory

  Questo sembra far chiamare il sistema rename("a", "z/"), quindi dovrebbe essere al sicuro dalle vulnerabilità al momento del check-to-time-of-use, nel caso in cui qualcuno stia gestendo lo stesso set di file contemporaneamente.

• In alternativa, utilizzare mv -t "$dir" "$file". Ancora una volta, si lamenterà se $dirnon è una directory.

• Utilizzare l' -nopzione per impedire la sovrascrittura di file esistenti:

  -n, --no-clobber
      do not overwrite an existing file

  Non gli impedirà di rinominare il primo file, ma non lo eliminerà con gli altri.

  Questo sembra chiamare un piano rename(), quindi potrebbe non essere sicuro con la gestione simultanea. (C'è renameat2()che supporterebbe una bandiera per impedire la sovrascrittura.)

Anche se apparentemente non è il caso per te, è possibile che tu possa farlo e non perdere i file. Ciò richiederebbe che una delle due cose sia vera:

• Uno o più "collegamenti fisici" agli stessi file esistono altrove nel filesystem
• Uno o più processi hanno un file aperto

I filesystem Unix consentono a più di una voce della directory di fare riferimento allo stesso identico contenuto del file . Questo si chiama " collegamento reale ". È possibile creare collegamenti reali con il lncomando, senza l' -sopzione comune (soft / simbolica). Finché esiste almeno un collegamento reale al contenuto del file, non verrà riutilizzato dal filesystem.

(Nota a margine, le autorizzazioni si applicano in genere al contenuto del file, non alla voce della directory. Ecco perché un utente normale a volte può eliminare un file di proprietà root, ma non scriverlo. L'operazione di cancellazione modifica la cartella, non il file stesso. )

Inoltre, il file system non riutilizzerà il contenuto del file, purché almeno un processo abbia il file aperto. Anche se non esiste alcuna voce nella directory, il filesystem non considererà lo spazio libero fino a quando nessun processo lo avrà aperto. Il file può essere recuperato dal file system virtuale /proc/<pid>/fdda rootfinché il file rimane aperto. (Grazie @fluffysheap.)