Newsgroup: it.comp.os.linux.iniziare
Titolo: Indicizzare i contenuti di una directory

Ciao,
avrei bisogno di uno strumento che, data una directory, ne indicizza i 
contenuti e ne permette di ricercarne i contenuti, comprendendo anche 
gli archivi in essa contenuti, e anche gli archivi contenuti negli 
archivi stessi.
 
Ad esempio, all'interno della directory da indicizzare ho l'archivio 
2014.tar che a sua volta contiene l'archivio FATTURE.zip che a sua volta 
contiene l'archivio GENNAIO.bz2 che contiente l'archivio 
FATTURA_2014_01.tgz che finalmente contiene il file FATTURA_2014_01.PDF:
 
<directory>
   |_2014.tar
     |_FATTURE.zip
       |_GENNAIO.bz2
         |_FATTURA_2014_01.tgz
           |_FATTURA_2014_01.PDF
 
 
come potrei fare ad indicizzare (e successivamente ricercare) il file 
FATTURA_2014_01.PDF ?
 
Non mi serve indicizzare il CONTENUTO di FATTURA_2014_01.PDF; vorrei 
solo di riuscire a sapere se esiste o meno all'interno della directory 
<directory>.
 
Ricordo che nei tempi antichi (era il 1999 circa), Altavista offriva il 
suo software per indicizzare contenuti locali al proprio pc e anche un 
motore di ricerca web, che girava in locale, che permetteva la ricerca 
dei propri files precedendtemente indicizzati.
 
Sapete se esiste qualcosa per fare questo tipo di indicizzazione ?
Voi come fareste ?
 
Grazie,
Ciao !
 
Jack
-----------------------------------
JACK RADIO
Only original and unpublished music
http://stux.linkpc.net
 
-----------------------------------


Se serve solo sapere il nome del file, c'e` "mlocate", che
funziona con cron job ed indicizza i file.
Essendo giornaliero, si hanno i dati di ieri, a meno di
non farlo orario.
Non credo, ma forse e` possibile, che usi notify e quindi
aggiorni l'archivio in tempo reale.
 
Poi, da shell, con "locate qualcosa", viene fatta una richiesta
al data base.
 
bye,
 
-- 
 
piergiorgio

On 09/27/2015 02:54 PM, Piergiorgio Sartor wrote:> On 2015-09-27 13:38, 
J wrote:
 >> Ciao,
 >> avrei bisogno di uno strumento che, data una directory, ne indicizza i
 >> contenuti e ne permette di ricercarne i contenuti, comprendendo anche
 >> gli archivi in essa contenuti, e anche gli archivi contenuti negli
 >> archivi stessi.
 >>
 >> Ad esempio, all'interno della directory da indicizzare ho l'archivio
 >> 2014.tar che a sua volta contiene l'archivio FATTURE.zip che a sua volta
 >> contiene l'archivio GENNAIO.bz2 che contiente l'archivio
 >> FATTURA_2014_01.tgz che finalmente contiene il file FATTURA_2014_01.PDF:
 >>
 >> <directory>
 >>    |_2014.tar
 >>      |_FATTURE.zip
 >>        |_GENNAIO.bz2
 >>          |_FATTURA_2014_01.tgz
 >>            |_FATTURA_2014_01.PDF
 >>
 >>
 >> come potrei fare ad indicizzare (e successivamente ricercare) il file
 >> FATTURA_2014_01.PDF ?
<cut>
 >
 > Se serve solo sapere il nome del file, c'e` "mlocate", che
 > funziona con cron job ed indicizza i file.
 > Essendo giornaliero, si hanno i dati di ieri, a meno di
 > non farlo orario.
 > Non credo, ma forse e` possibile, che usi notify e quindi
 > aggiorni l'archivio in tempo reale.
 >
 > Poi, da shell, con "locate qualcosa", viene fatta una richiesta
 > al data base.
 
 
mlocate non cerca all'interno di archivi.
Io vorrei sapere se un file e' contenuto all'interno di un archivio 
(tar,zip,bz2,tgz,...) o in un ulteriore archivio contenuto nell'archivio 
stesso.
Grazie
Ciao!
 
Jack



Carino devo dire.
E' la prima volta che vedo una struttura simile,mi chiedo a cosa possa 
servire, mi sembra la complicazione delle cose semplici.
Comunque a parte questo sw preparati per questo non ne conosco, ma con 
un bel shell script è facilmente risolvibile.
 

 un bel shell script è facilmente risolvibile.
 
Anch'io pensavo a uno script, pero' non credo che con bz2 si possa
leggere il nome dei file di GENNAIO.bz2 senza scompattare prima il
FATTURE.zip.
 
Percio' tanto vale scompattare tutto e poi andare con un locate dedicato
a quella sola directory, che puoi conservare anche dopo aver magari
cancellato tutto il ramo scompattato.
 
 
-- 
Tanti saluti
 


Credo, tra l'altro, esistano dei "zip" filesystem,
con fuse, magari e` possibile, se conveniente,
montare i vari zip (r/o) e poi fare il locate.
 
bye,
 
-- 
 
piergiorgio


Non ho fatto accenni a come funzioni lo script di shell ma comunque è 
ovvio che occorre adottare alcune tecniche come lo spacchettamento in 
dir. temporanee od al mount su file se possibile.
 


Chiedo scusa,piccola correzione:
mount da file non su file, i loop device insomma.
 

 montare i vari zip (r/o) e poi fare il locate.
 
Fuse non lo conosco per questo ruolo, pero' se son file di testo non
prendono molto posto, io li lascerei sempre tutti non zippati. Comunque
(dico per nhuik) io scompatterei tutta la directory 2014.tar (che poi
non so perche' non e' stata fatte direttamente in .tgz, ci deve essere
lo zampino di Uindous visto anche il tutto maiuscolo) e poi creerei il
file 2014.locate, col quale basta dare "locate -d 2014.locate GENNAIO"
per la ricerca di cosa tutto c'e' in GENNAIO.
 
Comunque caro ti costa poi quando l'hai trovato scompattare a cascata,
e' molto scomodo! guarda che oggi non e' piu' come un tempo: tutta la
dir scompattata ti prende (certamente, penso) molto meno d'un film.
 
 
-- 
Tanti saluti
 


si puo' fare, il problema è che per farlo devi conoscere già cosa ogni 
archivio contiene, quindi non risolve il problema dell' OP
 
 
unzip -c FATTURE.zip | bzcat GENNAIO.bz2 |tar tvzf -
 


Mica vero, il comando file che ci sta a fare ?
 

Addi' 27 set 2015, RedWiz scrive:

Giusto! lo scompatti in memoria, lo dai in pasto a bzcat che scompatta
solo GENNAIO.bx2 e sempre in memoria, infine entra in gioco tar per il
tgz. A questo punto allora si puo' dare "tar -t -" e abbiamo la lista.
Ma allora risalendo, si puo' chiedere solo la lista anche a bzcat, e poi
dare un comando tipo "for j in nomi_lista; do la_tua_riga" (con $j al
posto di GENNAIO.bz2) e dirottando l'output sui file lista-$j. Risalendo
ancora si puo' fare lo stesso anche per unzip. Quindi dovremmo esserci.
 
Pero' secondo me si fa prima a scompattare tutto su disco e poi dare
updatedb della sola directory dove si scompatta.
 
 
-- 
Tanti saluti
 


Facendo cosi (con le pipe) si assume una struttura fissa e rigida
Si puo fare di meglio.
 


Be' postaglielo a J no?! io secondo me il consiglio di come farei io
gliel'ho gia' detto, se decide di scompattare su disco (per poi
cancellare o no) gli posso dare le righe di comando per usare locate,
sono collaudatissime perche' ho molti db separati, in modo che locate
di default cerca solo tra i file di sistema escludenso tutta /home.
 
 
-- 
Tanti saluti
 


Ti crei un elenco di file all'interno di una variabile, se fai
elenco=`ls *.*`
ti ritrovi la variabile elenco contenente i file e le directory
se il nome contiene tar alla fine o zip
esegui i comandi per generare la lista
tar -t visualizza il contenuto
 
fai un ciclo e dentro il ciclo ricerchi i vari contenuti
scatole cinesi.
Forse devi lavorare sull'output di tar e zip...
 
se hai messo uno zip dentro un tar o viceversa non saprei
 
ciao e buon linux

            |_FATTURA_2014_01.PDF
 
giusto per curiosità, da dove nasce l'esigenza di tale struttura invece 
di mettere il PDF direttamente in uno ZIP o simile?
 
 
 
-- 
/-\ /\/\ /\/\ /-\ /\/\ /\/\ /-\ T /-\ ... ¯\_(ツ)_/¯


E' domenica e preferisco fate altro che mettermi a fare script di shell
 
 


La struttura e' solo un esempio, ma rappresenta bene la situazione in 
cui si trova la directory, che mi trascino dietro da anni, in cui ci 
metto tutto quello che "non mi serve piu' ma magari in futuro mi 
servira'", come per esempio i file relativi ai vecchi clienti.
 
Sono 160 GB di dati, tra archivi, sotto-archivi, immagini di macchine 
virtuali, file iso, ecc. ecc. ed e' venuta l'ora di mettere un po' di 
ordine (ci sono dentro 20 anni di files).
 
Non pensavo fosse una esigenza cosi' poco diffusa che non esiste niente 
di pre-confezionato. Mi sono fatto uno script, che non sara' ne' 
elegante ne' veloce, ma raggiunge il risultato.
 
Ciao,
Jack



puoi mostrarlo?
 
ciao e grazie!

 La struttura e' solo un esempio, ma rappresenta bene la situazione in
 
Non hai, pero`, risposto alla domanda.
Da dove viene *l'esigenza* ti tale struttura?
Giusto per curiosita`...
 
bye,
 
-- 
 
piergiorgio


Ha appena finito di girare, ci ha messo ore, ma alla fine ce l'ha fatta.
 
E' brutto, impresentabile, lento e infinitamente ottimizzabile, se 
qualcuno puo' sistemarlo ...
 
1) Copialo nella directory dove hai gli archivi e spostati in questa 
directory.
 
2) esegui
sh archive-manager.sh -i
come root per inizializzare.
Questo creera' tre files per ogni archivio .tar, .tgz, .tzx, e rar che 
trova nella directory corrente. Questi file conterranno la lista del 
contenuto degli archivi.
Lo script creera' nella directory corrente la directory temporanea 
tmparc che rimuovera' all' uscita.
A seconda di quanti archivi ci sono nella directory (e di quanti 
sotto-archivi contengono), lo script puo' metterci ore.
 
3) per fare una ricerca esegui:
sh archive-manager.sh -s <testo da cercare>
e dovresti avere un output che ti permette di capire in quale archivio 
(o sottoarchivio) e' contenuto il file che cerchi.
 
NOTA: se hai un archivio che contiene un gran numero di sotto-archivi 
che non sei interessato ad indicizzare, usa la variabile $FILTER in 
testa al programma per escludere la ricerca negli archivi il cui path e' 
presente nella variabile $FILTER. Ti accorgerai dell'esistenza di questo 
gran numero di archivi solo mentre il programma sta girando, magari da 
ore; in questo caso interrompi l'esecuzione con CTRL+C, rimuovi l'ultimo 
file creato con nome <nome archivio>.listarc#archives#list e rilancia 
con l'opzione -i.
 
Per ripartire da capo esegui:
rm -f *.listarc*
e dovrai reinizializzare gli indici con l'opzione -i.
 
 
#!/bin/sh
 
# exclude the following patterns (to avoid large numbers of archives 
that don't require to be parsed))
FILTER="/apps.|t-system-antivirus|/apps/|kernel-|modules-|i386|i686|x86|/liso-|packages/|slackBuild|slapt|StuxBuilds|qemu"
 
cd $(dirname "$0")
CDIR=`pwd`
 
atexit() {
	rm -fr $CDIR/tmparc
}
trap atexit EXIT KILL
 
list_archive() {
	local A="$1"
	local M="$2"
	echo "$A" | grep -q \.zip$
         if [ $? -eq 0 ]; then
		unzip -t "$A" | grep testing | sed -e s/^.*testing:\ //g -e s/\ 
*OK$//g -e s/^/$M\ /g
                 return $?
         fi
         echo "$A" | grep -q \.tar$
         if [ $? -eq 0 ]; then
                 tar tf "$A" | sed s/^/$M\ /g
                 return $?
         fi
         echo "$A" | grep -q \.tgz$
         if [ $? -eq 0 ]; then
                 tar tzf "$A" | sed s/^/$M\ /g
                 return $?
         fi
         echo "$A" | grep -q \.rar$
         if [ $? -eq 0 ]; then
		unrar v $A | grep "^    \." | cut -b65- | sed s/^/$M\ /g
                 return $?
         fi
         echo "Error: cannot list archive $A: unknown format"
         return 1
}
 
extractfile() {
	local A="$1"
	local T="$2"
	local M="$3"
	echo "$A" | grep -q \.tgz$
         if [ $? -eq 0 ]; then
		tar xzf "$A" "$T" || exit 1
		if [ ! -f "$T" ]; then
			echo "ERROR: cannot uncompress \"$T\" from \"$A\". Probably a link."
			return 1
		fi
		list_archive "$T" "$M" # | tee -a "$O"
                 return $?
         fi
         echo "$A" | grep -q \.tar$
         if [ $? -eq 0 ]; then
                 tar xf "$A" "$T" || exit 1
                 if [ ! -f "$T" ]; then
                         echo "ERROR: cannot uncompress \"$T\" from \"$A\"."
                         return 1
                 fi
                 list_archive "$T" "$M" # | tee -a "$O"
                 return $?
         fi
         echo "$A" | grep -q \.zip$
         if [ $? -eq 0 ]; then
                 unzip -q "$A" "$T" || exit 1
                 if [ ! -f "$T" ]; then
                         echo "ERROR: cannot uncompress \"$T\" from \"$A\"."
                         return 1
                 fi
                 list_archive "$T" "$M" # | tee -a "$O"
                 return $?
         fi
         echo "$A" | grep -q \.rar$
         if [ $? -eq 0 ]; then
                 unrar x "$A" "$T" || exit 1
                 if [ ! -f "$T" ]; then
                         echo "ERROR: cannot uncompress \"$T\" from \"$A\"."
                         return 1
                 fi
                 list_archive "$T" "$M" # | tee -a "$O"
                 return $?
         fi
 
	echo "Error: cannot extract $A: unknown format"
	return 1
}
 
process_archives_file() {
         ARCHIVE_FILE="$1"
	OUTPUT_FILE="${1}#list"
	if [ -s "$OUTPUT_FILE" ]; then
		echo "Keep existing file \"$OUTPUT_FILE\"."
		return
	fi
	>"$OUTPUT_FILE"
	MAIN_ARCHIVE=$(basename "`echo \"$ARCHIVE_FILE\" | cut -d\# -f1`" .listarc)
	if [ ! -f "$MAIN_ARCHIVE" ]; then
		echo "ERROR: cannot find archive file [$MAIN_ARCHIVE] while processing 
[$ARCHIVE_FILE]."
		exit 1
	fi
	echo "MAIN[$MAIN_ARCHIVE]"
	while read line ; do
		echo "$line" | fgrep -q " -> " && continue
		ARC_PATH="$line"
		MD5=`echo "$ARC_PATH" | md5sum | cut -d' ' -f1`
		echo "Archive \"${MAIN_ARCHIVE}:$ARC_PATH\" [$MD5]" | tee -a 
"$OUTPUT_FILE"
	        rm -fr $CDIR/tmparc
         	mkdir -p $CDIR/tmparc
		cd $CDIR/tmparc || exit 1
		extractfile "../$MAIN_ARCHIVE" "$ARC_PATH" "$MD5" | tee -a 
"../$OUTPUT_FILE"
		cd ..
		rm -fr $CDIR/tmparc
	done<<EOT
$(egrep -v "$FILTER" "$ARCHIVE_FILE")
EOT
	touch -r "$ARCHIVE_FILE" "$OUTPUT_FILE"
	echo "Done in $OUTPUT_FILE"
}
 
init() {	
	for i in *.tgz *.tzx ; do
		[ ! -f "$i" ] && continue
		echo "Processing [$i]"
		if [ ! -s "${i}.listarc" ]; then
			tar tzf "$i" > "${i}.listarc"
			touch -r "$i" "${i}.listarc"
		else
			echo "Keep existing \"${i}.listarc\""
		fi
	done
 
	for i in *.tar ; do
		[ ! -f "$i" ] && continue
         	echo "Processing [$i]"
		if [ ! -s "${i}.listarc" ]; then
         		tar tf "$i" > "${i}.listarc"
         		touch -r "$i" "${i}.listarc"
		else
         	        echo "Keep existing \"${i}.listarc\""
	        fi
	done
 
	for i in *.rar ; do
         	[ ! -f "$i" ] && continue
         	echo "Processing [$i]"
         	if [ ! -s "${i}.listarc" ]; then
                 	#unrar v "$i" > "${i}.listarc"
			unrar v $i | grep "^    \." | cut -b65- > "${i}.listarc"
                 	touch -r "$i" "${i}.listarc"
         	else
         	        echo "Keep existing \"${i}.listarc\""
	        fi
	done
 
         for i in *.zip ; do
                 [ ! -f "$i" ] && continue
                 echo "Processing [$i]"
                 if [ ! -s "${i}.listarc" ]; then
                         unzip -t "$i" > "${i}.listarc"
                         touch -r "$i" "${i}.listarc"
                 else
                         echo "Keep existing \"${i}.listarc\""
                 fi
         done
 
	for i in *.listarc ; do
		[ ! -f "$i" ] && continue
		echo "Processing [$i]"
		if [ ! -s "${i}#archives" ]; then
			egrep '\.tgz$|\.txz$|\.tar$|\.zip$|\.rar$' "$i" | grep -v ' -> ' > 
"${i}#archives"
			touch -r "$i" "${i}#archives"
		else
			echo "Keep existing \"${i}#archives\""
		fi
	done
	find . -name '*#archives' -maxdepth 1 -size 0 -exec rm {} \;
 
	for i in *\#archives ; do
		echo "Processing archive file [$i]" >&2
		process_archives_file "$i"
	done
 
}
 
search() {
	fgrep -i "$1" *.listarc*
}
 
usage() {
	echo "Usage: `basename \"$0\"` [ -i (init) | -s (search) <search 
string> | -p (process archive file) <archive file> ]"
}
 
case "$1" in
	"-i")
		init
	;;
	"-s")
		if [ -z "$2" ]; then
			usage
			exit 1
		fi
		search "$2"
	;;
	"-p")
                 if [ -z "$2" ]; then
                         usage
                         exit 1
                 fi
		process_archives_file "$2"
	;;
	*)
		usage
	;;
esac
 
 
 
 
Ciao !
 
Jack
-----------------------------------
JACK RADIO
Only original and unpublished music
http://stux.linkpc.net
 
-----------------------------------
 
 
 

 FATTURE.zip.
 
   Non con bunzip2, ma con unzip puoi avere l'elenco dei file contenuti 
in un archivio .zip senza scompattarlo.  Da man zip(1):
 
        -l     list archive files (short format).  The names,
               uncompressed file sizes  and  modification  dates and
               times of the specified files are printed, along with
               totals  for  all  files  specified.
 
   Ciao,
 
 
-- 
Alessandro Selli 
http://alessandro.route-add.net
 
AVVERTENZA: i messaggi inviati a "trappola" non mi arriveranno.
WARNING: messages sent to "trappola" will never reach me.

                totals  for  all  files  specified.
 
Si' questo del list di zip lo sapevo, non sapevo che bunzip2 non lo fa,
ma in ogni caso dicevo nel senso che anche se ad esempio un file.zip
contiene un altro file2.zip, non posso vedere la lista di file2.zip
senza scompattare file.zip. Non so invece come faccia zgrep a cercare
stringhe senza scompattare almeno in memoria.
 
 
-- 
Tanti saluti
 

 stringhe senza scompattare almeno in memoria.
 
   È così, decomprime.  In Debian Jessie zgrep è uno script di shell che 
esegue gzip -cdfq .


 esegue gzip -cdfq .
 
Ah ecco, TNX.
 
 
-- 
Tanti saluti