# [rm] effacer un fichier par rapport à son ancienneté

## yesi

salut,

1 - disons que j'ai deux ou trois fichiers:

toto-20-05-2007

toto-25-05-2007

toto-30-05-2007

j'aimerais effacer le plus ancien des deux ou trois?

comment pourrais-je le faire?

2 - maintenant, j'aimerais définir une date précise à partir d'une date "donnée":

j'ai une date 01-06-2007

je voudrais effacer le fichier d'il y a deux jours de la date 01-06-2007

comment pourrais-je faire ça?

pour rappel:

date -d "2 day ago" '+%d-%m-%Y'     affiche la date d'il y a deux jours

merci d'avance de vos suggestions.Last edited by yesi on Fri Jun 15, 2007 10:22 am; edited 3 times in total

----------

## Bapt

Je ne sais pas quel shell tu utilises, si tu as du zsh (prosel quand tu nous tiens  :Smile: ) :

```

autoload -U age

print *(e:age today now:)             # files modified today

print *(e-age 17:00 now-)             # files modified since 5 pm

print *(e-age yesterday,17:00 now-)   # ... since 5 o'clock yesterday

print *(e-age 2006/12/25 today-)      # ... from last Christmas before today

print *(e-age 1970/01/01 yesterday-)  # ... before yesterday

and so on.  Note that "today" is a specific time, i.e. midnight last

night.

```

extrait de la ml : http://www.zsh.org/mla/users/2007/msg00427.html

a éventuellement combiner avec zsh/datetime : 

http://grml.org/zsh/zsh-lovers.html section zsh/datetime  pour des exemples.

----------

## yesi

je suis en bash.

Bapt: 

je n'ai pas encore le temps de ragerder zsh.

Mais c'est dans mes projets après t'avoir lu et d'autres encore... :Smile: 

----------

## gbetous

Tu veux chercher le plus vieux en te basant sur le nom ? Ou sur la date du fichier ?

----------

## yesi

sur la date, bien sûr.

----------

## gbetous

tente un truc du style "echo rm `ls --sort=time | head -1`

si c'est pas le bon (style t'as le premier au lieu du dernier) tu remplaces "head" par "tail"   :Wink: 

bon, avant de tenter ça, bien sur, tu fais des essais pour vérifier que tout va bien, puis tu supprimes le "echo" !

----------

## yesi

 *Quote:*   

> echo rm `ls --sort=time | head -1`

 

ce n'est pas ce que j'avais pensé faire au début mais ça résout "mon" problème.

```
rm `ls --sort=time toto* | tail -1`
```

merci.  :Smile: 

----------

## yesi

 *Quote:*   

> Tu veux chercher le plus vieux en te basant sur le nom ?

 

je ne vois pas ce que tu veux dire par là...

----------

## pititjo

 *yesi wrote:*   

>  *Quote:*   Tu veux chercher le plus vieux en te basant sur le nom ? 
> 
> je ne vois pas ce que tu veux dire par là...

 

Il veut dire que dans ton exemple, la date était contenue dans les nom de fichier, il te demandait donc si tu voulait te baser sur cette date (dans le nom de fichier) ou sur les metadonnées du file system.

(enfin je crois   :Rolling Eyes:  )

----------

## dmganges

Bjr,

/home/dufour/tmp

# find . -mmin +10000 -exec ls {} \; |more

./kilpart.exe

./mplayASgY4r

./mplayCoycW7

./mplaypQDuuc

./mplaym4n6xa

./mplay98OM4A

./mplaySgL2Of

./mplayiOG2pB

./mplayORIZ1r

./mplay5OHD2i

./kilpart.zip

./mplayEX4YZf

./mplayqT1B1M

si tu fais :

/home/dufour/tmp

# find . -mmin +10000 -exec rm {} \;

tu les effaces !

A toi de choisir finement le paramètre temps

ATTENTION c'est récursif !!! et il faut un caractère <espace> entre } et \

-mmin n

    Fichier dont les données ont été modifiées il y a n minutes. 

-mtime n

    Fichier dont les données ont été modifiées il y a n*24 heures.

Etc...

http://jp.barralis.com/linux-man/man1/find.1.php

Sois prudent !

Bye

----------

## gbetous

 *pititjo wrote:*   

> 
> 
> Il veut dire que dans ton exemple, la date était contenue dans les nom de fichier, il te demandait donc si tu voulait te baser sur cette date (dans le nom de fichier) ou sur les metadonnées du file system.
> 
> (enfin je crois   )

 

C'était exactement ça !   :Cool: 

----------

## yesi

 *Quote:*   

> Tu veux chercher le plus vieux en te basant sur le nom ? Ou sur la date du fichier ?

 

oki

et maintenant, si je voulais me baser sur le nom... :Smile: 

en tout cas, merci pour les diverses solutions.

----------

## dmganges

RE,

Tu fais un petit script par exemple ess :

echo Nom du fichier ?

read FIC

find . -print | grep $FIC |

while read PASS

do

    echo $PASS

    rm $PASS

done

Tu le rends exécutable :

chmod u+x ess

Tu le lances :

/home/dufour

# ./ess

Nom du fichier ?

toto

./tmp/toto

./toto

/home/dufour

# find . -print |grep toto

ISSONPU   :Smile: 

Remarques que tu aurais pu mettre en nom de fichier  tot*

Pour effacer tous les fichiers dont le nom commence par "tot"

ATTENTION c'est toujours récursif... j'aime bien le récursif   :Very Happy: 

Bye

----------

## dmganges

Tiens, avant que tu ne le demandes...

Et si je veux effacer un fichier contenant une chaine de caractère donnée ?

# cat esss

echo Nom du fichier ?

read FIC

echo Chaine ?

read CHAIN

find . -print | grep $FIC |

while read PASS

do

        echo $PASS

        fgrep $CHAIN $PASS && rm $PASS

done

/home/dufour

# find . -print |grep toto

./tmp/toto

./toto

Seul ./tmp/toto contient "coucou"

/home/dufour

# ./esss

Nom du fichier ?

toto

Chaine ?

coucou

./tmp/toto

coucou

./toto

/home/dufour

# find . -print| grep toto

./toto

./tmp/toto N'est plus LA !

si tu veux effacer les fichiers qui contiennent "coucou" sans tenir compte de leurs noms :

/home/dufour

# ./esss

Nom du fichier ?

*

Chaine ?

coucou

Enfin, maintenant tu adaptes ...

Ca s'appelle la puissance du Shell !

et si tu le couples avec d'autres commandes comme sed, ed et awk, il n'y a pas de limite à la puissance !

Mais je reconnais, les expressions régulières utilisées avec ces outils sont rebutantes, Il y a un très bon bouquins chez O'Reilly :

Maîtrises des expressions régulières par Jeffrey E. F. Frield.

Mais avant d'en arriver là, il vaut mieux maîtriser, par exemple :

Le Shell bash ET/OU Introductions aux Scripts Shell Tjs chez O'Reilly...

A mon avis le premier "Le Shell bash" est un bon début...

Tu trouveras aussi sur Internet, et gratis, de quoi bien commencer...

Un petit conseil, si tu permets, regardes les scripts du système, il y en a qui vallent leur pesant d'or... dans /etc entre autre...

Bye

----------

## yesi

Que du bon!

Merci pour les exemples!

----------

## _Seth_

J'utilise bash mais pas assez souvent pour le "parler" couramment, du coup mes 2 références en cas d'oubli ou de séchage intempestifs sont :

 Advanced Bash-Scripting Guide

 BASH Programming - Introduction HOW-TO

----------

## yesi

en fait je me rends compte que mon script ne marche pas correctement:

donc en gros, je sauvegarde des fichiers compressés avec le tag de la date, dans un répertoire /backup:

toto-14-01-2007

toto-15-01-2007

toto-16-01-2007...

et moi, je voulais supprimer par ssh le(s) fichier(s) les plus anciens en gardant au minimum au moins deux fichiers compressés les plus recents.

```
ssh machine "( set -- /backup/toto*;if [ $# -ge 3 ];then rm -f `ls --sort=time $@ | tail -1`;fi )"
```

ou 

```
ssh machine "( if [ `ls /backup/toto* |wc -l` -ge 3 ];then rm -f `ls --sort=time $@ | tail -1`; fi )"
```

mais bon ça ne marche pas trop...

en gros les `` dans ssh ne sont pas gérés correctement je crois...parce que ça me sort rien...

Quels sont les restrictions de ssh pour les commands à introduire?

Merci d'avance.

----------

## mornik

Salut,

Je viens de mettre en place au taf un petit script pour gerer nos sauvegarde. Par contre moi je fonctionne par version.

L'idée est de dire je conserve 1, 2 ou x version de mon fichier. Le fichier est sauvegarder avec une date de traitement et son numéro de version :

fic1-20070512-1

fic1-20070512-2

fic1-20070513-3

A chaque sauvegarde il sauvegarde en version +1 puis supprime le nombre d'anciennes versions de trop et renomme l'ensemble pour que les version partent de 1.

La date ne sert que pour savoir à quelle "date" de traitement on a fait la sauvegarde.

Mon script est compatible bash et ksh (hp).

Si ça interresse qq1 je le posterai lundi en rentrant du week-end :p

----------

## yesi

hi,

je suppose que ton fichier :

- n'est pas très gros en taille

- est sauvegardé plusieurs fois par jour 

sinon je ne vois pas trop l'intérêt de taggué en version...

mes répertoires sont compressés, puis sauvegardés par ssh entre autre une fois par jour( car c'est très gros).

----------

## mornik

En faite une compression est effectuée par un autre script, selon certaines conditions.

L'idée, était de n'avoir que x versions. Peut importe quand on exécutel'appli et donc sans tenir compte de la date de génération du fichier. La date n'est utilisé que pour servir de repère avec l'ordonnanceur.

Voila en gros le pourquoi du comment.

----------

## yesi

ça m'intéresserait de voir ton script...

 :Smile: 

----------

## mornik

Voila :

```
#!/bin/sh

typeset -i nb_version=3

typeset date_tmp="20070614"

typeset fichier_source="fic1"

typeset repertoire_source="origine"

typeset repertoire_cible="cible"

# sauvegarde

typeset test="cible/\${fichier_source}*_1"

# recuperation de la valeur de cette variable

fic_test=`eval echo ${test}`

if [ ! -e "${fic_test}" ]; then

 echo "sauvegarde du fichier"

 echo "cp ${repertoire_source}/${fichier_source} ${repertoire_cible}${fichier_source}_${date_tmp}_1"

 cp ${repertoire_source}/${fichier_source} ${repertoire_cible}/${fichier_source}_${date_tmp}_1

 exit 0

fi

 

#if [  -e "cible/${fichier_source}*" ]; then

 typeset -i Nb_version_existante=$(ls cible/${fichier_source}*|wc -l)

 echo "sauvegarde du fichier en generation +1"

 typeset -i genplus1=$(expr ${Nb_version_existante} + 1)

 echo "cp ${repertoire_source}/${fichier_source} ${repertoire_cible}/${fichier_source}_${date_tmp}_${genplus1}"

 cp ${repertoire_source}/${fichier_source} ${repertoire_cible}/${fichier_source}_${date_tmp}_${genplus1}

 typeset -i Nb_version_existante=$(expr ${Nb_version_existante} + 1)

 

# test si le nb de version presentent est < au nombre de versions voulues

# si Nb_version_existante<nb_version alors on quitte

 

if [ ${Nb_version_existante} -le ${nb_version} ]; then

 echo "Nb_version_existante : "${Nb_version_existante}

 echo "nb_version : "${nb_version}

 echo "rien a faire"

 exit 0

fi

 

#typeset -i Compteur_de_fichiers=1

typeset -i Cpt=1

#while [ ${Cpt} -lt ${Nb_version_existante} ]

while [ ${Cpt} -lt ${Nb_version_existante} ] || [ ${Cpt} -lt ${nb_version} ]  || [ ${Nb_version_existante} -lt ${nb_version} ]

#for fichier_present in $(ls cible/\${fichier_source}*)

 do

 typeset test2="cible/\${fichier_source}*_${Cpt}"

 typeset fichier_present=`eval echo ${test2}`

 typeset -i increment=$(echo ${fichier_present}|awk -F_ '{print $NF}')

 typeset -i incrementplus1=$(expr ${increment} + 1)

 typeset -i taille_increment=${#increment}

 typeset -i taille_fichier=${#fichier_present}

 typeset -i taille_fichier_ss_incr=$(expr ${taille_fichier} - ${taille_increment})

 typeset fichier_ss_incr=$(echo ${fichier_present}|cut -c1-${taille_fichier_ss_incr})

 typeset test3="cible/\${fichier_source}*_${incrementplus1}"

 typeset fichier_present2=`eval echo ${test3}`

 typeset -i increment2=$(echo ${fichier_present2}|awk -F_ '{print $NF}')

 typeset -i increment2plus1=$(expr ${increment2} + 1)

 typeset -i taille_increment2=${#increment2}

 typeset -i taille_fichier2=${#fichier_present2}

 typeset -i taille_fichier_ss_incr2=$(expr ${taille_fichier2} - ${taille_increment2})

 typeset fichier_ss_incr2=$(echo ${fichier_present2}|cut -c1-${taille_fichier_ss_incr2})

 #echo "delete des version anciennes : ${fichier_ss_incr}${Cpt}"

 #echo "cp ${fichier_ss_incr}${Cpt} ${fichier_ss_incr}${Cpt}"

 echo "rm *_${Cpt}"

 rm ${repertoire_cible}/*_${Cpt}

 echo "cp ${fichier_ss_incr2}${increment2} ${fichier_ss_incr2}${Cpt}"

 #cp ${fichier_ss_incr}${incrementplus1} ${fichier_ss_incr}${Cpt}

 cp ${fichier_ss_incr2}${increment2} ${fichier_ss_incr2}${Cpt}

 Cpt=$(expr ${Cpt} + 1)

 done

 

typeset -i Nb_version_existante=$(ls cible/${fichier_source}*|wc -l)

echo $Nb_version_existante

while [ ${nb_version} -lt ${Nb_version_existante} ]

 do

 typeset test2="cible/\${fichier_source}*_${Nb_version_existante}"

 typeset fichier_present=`eval echo ${test2}`

 typeset -i increment=$(echo ${fichier_present}|awk -F_ '{print $NF}')

 typeset -i taille_increment=${#increment}

 typeset -i taille_fichier=${#fichier_present}

 typeset -i taille_fichier_ss_incr=$(expr ${taille_fichier} - ${taille_increment})

 typeset fichier_ss_incr=$(echo ${fichier_present}|cut -c1-${taille_fichier_ss_incr})

 echo "rm ${fichier_ss_incr}${increment}"

 rm ${fichier_ss_incr}${increment}

 typeset -i Nb_version_existante=$(ls cible/${fichier_source}*|wc -l)

 done

```

Il s'agit de la derniere version de travail. Pas du tout optimisée, mais fonctionnelle. Je passerai à la partie optimisation apres la prochaine série de test.

Les premieres variables permettent de définir le nombre de versions que tu veux, la date (nous on la passe en paramètres), le répertoire d'origine et le répertoire cible).

Voila A+

----------

## yesi

c'est intéressant!

Merci!   :Smile: 

----------

## mornik

de rien  :Wink: 

----------

