[BASH] lista di file di una partizione

PS: attento anche alla variabile $dimensione. Nel post (l'ultimo contenente codice bash) l'ho utilizzata in due contesti diversi con due significati diversi. Nel primo caso contiene la dimensione in blocchi della partizione, nel secondo caso (all'interndo del comando "find") contiene la dimensione minima da ricercare. Attento quindi a non confonderti ed eventualmente ad utilizzare due nomi diversi all'interno dello script.

edit: a scanso di equivoci ora gli ho cambiato nome

niente da fare bingel, il mountpoint non si vede, e la ricerca/eliminazione dei file produce ancora risultati con no such file or directory o permission denied (dopo tentata cancellazione di file inesistente) quindi ho lasciato come era prima che mi dava risultati migliori almeno credo

così ho parzialmente risolto (credo)

Codice: Seleziona tutto

partizione=$(sudo fdisk -s /dev/sd*[0-9] | sort -gk2 | tail -n 1)
dimensione_partizione=$(sudo fdisk -s /dev/sd*[0-9] | sort -gk2 | tail -n 1 | cut -d ":" -f 1  )
mountpoint=$(grep "$partizione" /etc/mtab | cut -d " " -f 2 )
#devo stampare il punto di mount ma non funziona
percento=(`df $dimensione_partizione | sed 1d | awk '{print $5}'`)
      echo
                echo "La partizione sd[x][n] più grande è : $partizione "
                echo "$mountpoint"
        echo "e occupa il $percento della partizione primaria "
      echo


tuttavia ancora una volta il mountpoint non funziona, mi lascia una riga bianca, il fatto che io faccia girare lo script su una macchina virtuale può influenzare la cosa?

Posta l'output del comando:

Codice: Seleziona tutto

mount

Correggi inoltre questo comando in questo modo:

Codice: Seleziona tutto

dimensione_partizione=$(sudo fdisk -s /dev/sd*[0-9] | sort -gk2 | tail -n 1 | cut -d ":" -f 2  ) #attenzione a mettere 2 al posto di 1 in fondo al comando

Non è possibile che il codice che hai postato porti a dei risultati corretti pertanto non credo tu abbia risolto.

Hai fatto le prove da terminale che ti dicevo?

Prova eventualmente a modificare il seguente comando (togliendo le virgolette):

Codice: Seleziona tutto

mountpoint=$(grep $partizione /etc/mtab | cut -d " " -f 2)

PS: comunque vedo che ad ogni post la tua confusione aumenta soltanto invece che diminuire pertanto non so se sia giusto continuare in questo modo.

Se postassi il testo del problema direi che forse potremmo esserti più di aiuto (tuttavia non sperare mi metta io a risolverlo al posto tuo): non ti servirebbe a granché. Cerca piuttosto di capire ciò che fai studiando i comandi e le relative opzioni che incontri.

Si ho fatto le prove da terminale seguendo quello che mi hai detto:
ovvero eseguendo questo codice che mi hai detto

Codice: Seleziona tutto

partizione=$(sudo fdisk -s /dev/sd*[0-9] | sort -gk2 | tail -n 1 | cut -d ":" -f 1)
echo $partizione
dimensione_partizione=$(sudo fdisk -s /dev/sd*[0-9] | sort -gk2 | tail -n 1 | cut -d ":" -f 2)
echo $dimensione_partizione
mountpoint=$(grep "$partizione" /etc/mtab | cut -d " " -f 2)
echo $mountpoint

ottengo il seguente risultato

Codice: Seleziona tutto

/dev/sda1
7863296
/


questo è l'output del comando mount come mi hai chiesto:

Codice: Seleziona tutto

/dev/sda1 on / type ext4 (rw,errors=remount-ro,commit=0)
proc on /proc type proc (rw,noexec,nosuid,nodev)
sysfs on /sys type sysfs (rw,noexec,nosuid,nodev)
fusectl on /sys/fs/fuse/connections type fusectl (rw)
none on /sys/kernel/debug type debugfs (rw)
none on /sys/kernel/security type securityfs (rw)
udev on /dev type devtmpfs (rw,mode=0755)
devpts on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=0620)
tmpfs on /run type tmpfs (rw,noexec,nosuid,size=10%,mode=0755)
none on /run/lock type tmpfs (rw,noexec,nosuid,nodev,size=5242880)
none on /run/shm type tmpfs (rw,nosuid,nodev)
binfmt_misc on /proc/sys/fs/binfmt_misc type binfmt_misc (rw,noexec,nosuid,nodev)
Condivisa on /media/sf_Condivisa type vboxsf (rw,gid=124)
gvfs-fuse-daemon on /home/pagio/.gvfs type fuse.gvfs-fuse-daemon (rw,nosuid,nodev,user=pagio)
/dev/sr0 on /media/VBOXADDITIONS_4.1.8_75467 type iso9660 (ro,nosuid,nodev,uid=1000,gid=1000,iocharset=utf8,mode=0400,dmode=0500,uhelper=udisks)
Condivisa on /home/pagio/Scrivania/condivisa type vboxsf (rw)


Non so bingel io invece andando avanti ho praticamente risolto tutti i miei problemi, ora mi manca solo questo del fatto che non riesco a vedere il mountpoint della partizione il resto dovrei essere in grado di farlo da solo senza problemi
PS le modifiche che mi hai consigliato sopra non mi hanno aiutato inizio a pensare che l'output che mi da mountpoint cioè una slash sia corretto (vedendo l'output di mount), ma non capisco perchè è così

Esatto, l'output di mountpoint è corretto. Si tratta della directory radice (root).
Vedi, il problema è che ti mancano proprio le nozioni di base pertanto è difficile mettersi a programmare, seppure "in bash", senza avere un minimo di idea di come sia organizzato un file system o quant'altro.

Cmq mi fa piacere che la discussione, in qualche modo, ti sia potuta servire.

Le modifiche che ti avevo proposto in alcuni casi erano volte a correggere errori evidenti, per es.:

Codice: Seleziona tutto

dimensione_partizione=$(sudo fdisk -s /dev/sd*[0-9] | sort -gk2 | tail -n 1 | cut -d ":" -f 2  ) #attenzione a mettere 2 al posto di 1 in fondo al comando

ma erano fini a se stesse e non è che ti avrebbero dovuto aiutare a far si che lo script poi funzionasse (non sono ancora entrato nel merito del funzionamento dello script).

In ogni caso ribadisco: dovresti postare il testo del problema per permetterci di capire se quanto fai è corretto o meno ...e anche una versione aggiornata dello script.

ti ho mandato un pm, comunque ecco lo script aggiornato

Codice: Seleziona tutto

#!/bin/bash

partizione=$(sudo fdisk -s /dev/sd*[0-9] | sort -gk2 | tail -n 1 | cut -d ":" -f 1)
dimensione_partizione=$(sudo fdisk -s /dev/sd*[0-9] | sort -gk2 | tail -n 1 | cut -d ":" -f 2)
mountpoint=$(grep "$partizione" /etc/mtab | cut -d " " -f 2)
percento=(`df $partizione | sed 1d | awk '{print $5}'`)
      echo
      echo "La partizione sd[x][n] più grande è : $partizione "
      echo "la partizione è montata in : $mountpoint"
        echo "e occupa il $percento della partizione primaria "
      echo ""
function menu {

select menusel in "Visualizza la lista dei file della partizione inserendo m in bytes" "Cancella un file" "Esci";
do
   case $menusel in
      "Visualizza la lista dei file della partizione inserendo m in bytes")
         echo "Inserisci m, visualizza solo i file > di m nella partizione: "
         read dimensione
         echo "Di seguito i file appartenenti all'utente di dimensione superiore a $dimensione bytes:"
         #sudo find $mountpoint -type f -size +$dimensione\c -uid $(id -u)
         find $(grep "$partizione" /etc/mtab | cut -d " " -f 2) -size +$dimensione\c -uid $(id -u)
      ;;
   
      "Cancella un file")
         echo "Inserisci il nome del file che vuoi cancellare"
         read filename
         find $mountpoint -type f -name "$filename" -exec rm -f {} \;
         #devo mettere un if, se trova il file e lo elimina devi avvisarmi
         #se non lo trova mi dice che non l'ha trovato
         echo "la lista aggiornata è la seguente : "
         #sudo find $mountpoint -type f -size +$dimensione\c -uid $(id -u)
         find $(grep "$partizione" /etc/mtab | cut -d " " -f 2) -size +$dimensione\c -uid $(id -u)
      ;;
      "Esci")
         echo "Chiusura Script"
         exit 0
      ;;
   
   esac

   break

done
}

while true;
do
   menu;
done


tuttavia ora che va quasi tutto, il find mi dai dei problemi, cioè vedo troppa roba con permessi negati e quando provo a rimuovere mi dice che non ho i permessi (quindi non dovrei vederlo), ma avendo messo -f lo forzo e lo toglie uguale

...tuttavia ora che va quasi tutto, il find mi dai dei problemi, cioè vedo troppa roba con permessi negati e quando provo a rimuovere mi dice che non ho i permessi (quindi non dovrei vederlo), ma avendo messo -f lo forzo e lo toglie uguale

...con calma ci do un'occhiata cmq non è che stai cancellando file di sistema necessari a linux?!?!?!

non credo , sto cancellando solo file che trovo nella cartella Scaricati, quindi non dovrei aver distrutto niente per ora
visto che ci sono ti dico che una delle cartelle che mi sta dando più problemi, durante il find è la cartella /proc/ escono un casino di risultati con questa cartella con permesso negato

Ok, grazie e scusa ancora per la perdita di tempo che ti sto causando da ormai 2 giorni

Per me è un passatempo, un divertimento, non ti preoccupare. Pensa piuttosto a studiare e a cercar di far bene.

Ho dato un'occhiata al problema. Credo che il codice seguente faccia il suo dovere (anche se il minimo indispensabile). Considera che se due partizioni mostreranno la stessa percentuale di spazio usato (come output al comando "df"), solo una di esse sarà mostrata (ma credo che ai fini dell'esercizio sia più che sufficiente).
Un altro dei tanti probabili limiti di questo script è la lunghezza della lista stampata: se troppo lunga, è un problema in quanto sono visibili solo gli ultimi file presenti .

Codice: Seleziona tutto

#!/bin/bash

device=$(df -P | grep '^/dev/sd' | sort -gk5 | tail -n 1 | awk '{print $1}')
usedspace=$(df -P | grep '^/dev/sd' | sort -gk5 | tail -n 1 | awk '{print $5}')
mountpoint=$(df -P | grep '^/dev/sd' | sort -gk5 | tail -n 1 | awk '{print $6}')

echo
echo "La partizione con più spazio usato è: $device"
echo "La directory in cui tale partizione è montata è: $mountpoint"
echo "La percentuale di spazio usato di tale partizione è pari al $usedspace"
echo
echo "Inserire la dimensione minima, in MB, dei files da elencare contenuti"
echo "all'interno della partizione di cui sopra o digitare 'q' per uscire: "
### Al posto dell'IF all'interno del seguente ciclo WHILE sarebbe forse meglio usare un CASE
while read m; do
  if [[ $m = [Qq] ]]; then
    exit 0
  else
    if [[ $m =~ ^[0-9]+$ ]]; then
      break
    else
      echo "Scelta non valida. Inserire un valore intero o digitare 'q' per uscire:"
    fi
  fi
done
echo
echo "Attendere, creazione della lista dei files in corso..."
PS3=$(echo; echo "Inserire il numero corrispondente al file da eliminare o premere 'q' per uscire: ")
while true; do
  list=$(find $mountpoint -type f -size +$m\M -uid $(id -u) 2>/dev/null)
  if [ -n "$list" ]; then
    OIFS=$IFS
    IFS=$'\n'
    select file in $list; do
      if [ -n "$file" ]; then
        rm -f ${file}
        echo
        echo "Il file:"
        echo ${file}
        echo "è stato eliminato."
        echo
        echo "Attendere, aggiornamento lista in corso..."
        break
      else
        if [[ $REPLY != [Qq] ]]; then
          echo -n "File non trovato o scelta errata. "
        else
          exit 0
        fi
      fi
    done
    IFS=$OIFS
  else
    echo "Nessun file supera la dimensione impostata. Lista non generata. Esco"
    exit 0
  fi
done

A te l'onere di capire come l'ho ragionata (se qualcosa non ti è chiaro domanda pure)

Grazie mille, solo una cosa, adesso la partizione più grossa me la segna come /dev/sr0 e percentuale di spazio occupato 100% che quindi a me non va bene perchè deve essere di tipo /dev/sd[x][n]

Adesso vado a letto ma domani mi metto bene a studiare il codice che hai postato, mi manca ancora qualcosa da capire, ma non vorrei far domande senza prima aver almeno cercato su internet da solo

Prova a modificarlo così:

Codice: Seleziona tutto

device=$(df -P | grep "^/dev/sd*" | sort -gk5 | tail -n 1 | awk '{print $1}')
usedspace=$(df -P | grep "^/dev/sd*" | sort -gk5 | tail -n 1 | awk '{print $5}')
mountpoint=$(df -P | grep "^/dev/sd*" | sort -gk5 | tail -n 1 | awk '{print $6}')

...probabilmente però, con la ricerca tramite "grep" il professore desidera qualcosa che gli mostri anche che tu abbia capito anche cosa sia un'espressine regolare...

non è un problema bingel, sono qua per imparare apposta
Allora anche facendo così mi esce sempre sr0, quindi a questo punto se uso i comandi di prima per trovare partizione dici che i file che escono dopo sono corretti o mi escono risultati sbagliati?

questo è l'output che ottengo mettendo partizione come prima

Codice: Seleziona tutto

La partizione con più spazio usato è: /dev/sda1
La directory in cui tale partizione è montata è: /media/VBOXADDITIONS_4.1.8_75467
La percentuale di spazio usato di tale partizione è pari al 45%

Inserire la dimensione minima, in MB, dei files da elencare contenuti
all'interno della partizione di cui sopra o digitare 'q' per uscire:
1

Attendere, creazione della lista dei files in corso...
1) /media/VBOXADDITIONS_4.1.8_75467/32Bit/OS2/libc063.dll
2) /media/VBOXADDITIONS_4.1.8_75467/VBoxLinuxAdditions.run
3) /media/VBOXADDITIONS_4.1.8_75467/VBoxSolarisAdditions.pkg
4) /media/VBOXADDITIONS_4.1.8_75467/VBoxWindowsAdditions-amd64.exe
5) /media/VBOXADDITIONS_4.1.8_75467/VBoxWindowsAdditions-x86.exe


Appena ho tempo, magari domani mattina mi metto giù e ti commento tutti i comandi scritti qui, almeno puoi dirmi se quello che penso è giusto o meno

Hai ragione, togli gli asterischi dalle tre righe che ti ho detto di modificare e vedrai che funziona.

Per es.:

Codice: Seleziona tutto

device=$(df -P | grep "^/dev/sd*" | sort -gk5 | tail -n 1 | awk '{print $1}')

dovrà diventare:

Codice: Seleziona tutto

device=$(df -P | grep "^/dev/sd" | sort -gk5 | tail -n 1 | awk '{print $1}')

Sei un grande , adesso funziona tutto alla perfezione, probabilmente cercherò di unire i 2 script, un po' di quello mio/tuo e un po' del solo-tuo e alla fine ti posto quello completo come l'ho fatto
senza di te non ce l'avrei mai fatta veramente grazie di cuore ^^

siccome non mi piace prendere cose fatte senza capirle, inizio col chiederti i comandi che ho capito meno

IFS è una variabile interna che fa dei loop e può risolvere il problema dello spazio nelle varie path, giusto?
mentre OIFS non è una variabile interna ma solo una variabile di appoggio chiamata così per il nome, cioè Original Internal Field Separator giusto?
PS3 è invece usato in combinazione con select, mi pare di aver capito che il valore che gli dai lui lo esegue ogni volta che nel menu select scegli una delle voci giusto?
$REPLY è il value di ritorno di un comando read, in questo caso è il tasto cliccato nel select per decidere sul da farsi giusto?

L'unione mi preoccupa un po' !!! Comunque sono proprio curioso di vedere cosa ne viene fuori perché lo script così com'è (il mio), già da solo assolve a tutte le richieste del problema ...almeno mi pare.

Per quanto riguarda il discorso degli asterischi che ti ho fatto togliere, torno a ribadire che sarebbe certamente meglio far uso di un'espressione regolare più completa perché sebbene in pratica non esistano altri dispositivi di memorizzazione che iniziano per "sd" oltre ai dischi fissi, in teoria non è detto che non possano esistere, pertanto se ve ne fossero, l'espressione che abbiamo usato riporterebbe anche questi (e ciò non sarebbe corretto). Comunque in realtà è un problema minore. Con le espressioni regolari tuttavia non posso esserti di aiuto in quanto mi sono sempre risultate un po' indigeste e non vorrei farti far ca....te.

- IFS significa INTERNAL FIELDS SEPARATOR. E' una variabile interna che in pratica definisce come bash deve interpretare gli spazi tra le parole (o meglio, come separare i campi). Di default usa appunto gli spazi che stanno tra le parole pertanto in questo caso io gli ho detto di usare il fine linea risolvendo, proprio come dici tu, il problema dei nomi con gli spazi.

Di seguito una definizione più precisa:

This variable determines how Bash recognizes fields, or word boundaries, when it interprets character strings. IFS defaults to whitespace (space, tab, and newline), but may be changed, for example, to parse a comma-separated data file. Note that $* uses the first character held in $IFS.

Vedi: http://tldp.org/LDP/abs/html/internalvariables.html (anche per REPLY che è a sua volta una variabile interna)

- OIFS è esattamente quello che hai detto (la O io l'avevo pensata come OLD ma anche la tua interpretazione non è male)

- PS3 non è altro che il prompt usato da SELECT (vedi: http://www.thegeekstuff.com/2008/09/bas ... t_command/ oppure http://tldp.org/LDP/Bash-Beginners-Guid ... 09_06.html)

- REPLY: The default value when a variable is not supplied to READ (quando cioé si usa READ da solo e non READ VARIABILE ...quindi in pratica è il nome di default che assume la variabile usata da READ quando non si specifica un altro nome). Also applicable to SELECT menus, but only supplies the item number of the variable chosen (il valore digitato ...che può essere anche diverso dai numeri proposti nel menu), not the value of the variable itself (nel nostro caso il path dei files da eliminare).

Pensa le coincidenze: oggi mi ritrovo con la partizione del server su cui gira un programma di contabilità occupata al 100%.

Non faccio altro che prendere questo script e mettermi a liberare spazio sulla partizione.

Ho apportato anche una piccola miglioria (a dir il vero anche altre ma non c'entrano nulla con il tuo problema):

Codice: Seleziona tutto

list=$(find $mountpoint -type f -size +$m\M -uid $(id -u) -exec du -h {} \; 2>/dev/null | awk '{print $1, $2}' | sort -hr)

In pratica, in questo modo, riporta anche la dimensione dei file ordinandoli in base alla dimensione. L'awk serve solo a riformattare l'output togliendo inutili spazi che altrimenti creerebbero problemi con IFS.

sei un grande, ottima la funzione sopra che riordina per dimensione, me la tengo da parte in casi mi servisse e sono contento che tutto il tempo speso dietro la mia nabbaggine ti abbia almeno fruttato qualcosa
e grazie per le precisazioni sui comandi, ma adesso mi rimane da capire cosa significa 2>/dev/null , ho letto che reindirizza lo standard output, ma non ho capito cosa sia in questo caso

Ok ecco la fusione ho preferito tenere questa struttura per vari motivi:
1- si vedeva che non era fatto da un principiante mentre questo è molto più semplice e adatto a un novellino
2- il tuo non dava la possibilità di rimettere le dimensioni del file di cui creare la lista,mentre con questo si

unica cosa rimasta da fare è quel maledetto if, che non riesco ad attribuirgli un valore esatto del find, ho commentato il pezzo che manca dentro l'if, vorrei fare una cose del tipo if [ file trovato e eliminato (quindi basterebbe il value del find fosse true o false tipo) allora ecc ecc

Codice: Seleziona tutto

#!/bin/bash

partizione=$(df -P | grep "^/dev/sd" | sort -gk5 | tail -n 1 | awk '{print $1}')
usedspace=$(df -P | grep "^/dev/sd" | sort -gk5 | tail -n 1 | awk '{print $5}')
mountpoint=$(df -P | grep "^/dev/sd" | sort -gk5 | tail -n 1 | awk '{print $6}')
      echo
      echo "La partizione sd[x][n] più grande è : $partizione "
      echo "la partizione è montata in : $mountpoint"
        echo "e occupa il $usedspace della partizione primaria "
      echo ""
function menu {

select menusel in "Visualizza la lista dei file della partizione inserendo m in bytes" "Cancella un file" "Esci";
do
   case $menusel in
      "Visualizza la lista dei file della partizione inserendo m in bytes")
         echo "Inserisci m, visualizza solo i file > di m nella partizione: "
         read dimensione
         echo "Di seguito i file appartenenti all'utente di dimensione superiore a $dimensione bytes:"
         echo "#########################################################"
         find $mountpoint -type f -size +$dimensione -uid $(id -u) 2>/dev/null
      ;;
   
      "Cancella un file")
         echo "Inserisci il nome del file che vuoi cancellare"
         read filename
         find $mountpoint -type f -name "$filename" -exec rm -f {} 2>/dev/null \;
         #if [ file trovato e eliminato]; then
         #echo "il file "$filename" è stato eliminato"
         #else
         #echo "il file "$filename" non è stato trovato"
         #fi
         echo "#########################################################"
         echo "la lista aggiornata è la seguente : "
         find $mountpoint -type f -size +$dimensione -uid $(id -u) 2>/dev/null
      ;;
      "Esci")
         echo "Chiusura Script"
         exit 0
      ;;
   
   esac

   break

done
}

while true;
do
   menu;
done