Aller au contenu

Tache de fond supprimer les fichiers

GoobY13

Par GoobY13
dans GNU/Linux, *BSD et dérivés d'UNIX

Messages recommandés

GoobY13 Expérimenté

GoobY13

Posté(e)
Posté(e)

Hello

On m'a demandé de faire une tache de fond pour le serveur sous debian.

Ca consisterait en une heure donnée a supprimer tous les mp3 du serveur automatiquement.

On m'a parlé de cron ou anacron, mais je sais pas ce que c'est, je débute sous linux^^

Donc si vous avez une aide a me fournir (avec explications si vous avez le temps, histoire que je m'instruise^^).

Merci :eeek2:

Lien vers le commentaire
Partager sur d’autres sites
tuXXX Expérimenté

tuXXX

Posté(e)
Posté(e)
Pas compris la subtilité what, pkoi le 1er n'efface pas s'il y a un espace ?

rm -f `find / -iname '*.mp3'`

Cette commande va tout d'abord exécuter la commande :

find / -iname '*.mp3'

Cela va donner plein de lignes, par exemple :

/home/truc/fichier.mp3
/home/fichier avec espaces.mp3

Ensuite les `` vont prendre ces résultats et les mettre "en ligne", pour faire cela il va remplacer tous les retours à la ligne et les tabulations par des espaces.

On obtient donc :

rm -f /fichier.mp3 /fichier avec espaces.mp3

Vu comme ça, rm -f reçoit 4 paramètres : "/fichier.mp3" "/fichier" "avec" "espace.mp3".

Il y a plusieurs façon de régler ce problème :

1) utiliser le paramètre -exec de find :

find / -iname '*.mp3' -exec rm -f {} \;

Qui a l'inconvénient de devoir lancer de nombreuses fois la commande rm, et donc de ne pas forcément être efficace.

2) utiliser xargs

xargs utilisé tout seul (find / -iname '*.mp3' | xargs rm -f) ne sert à rien car le problème reste identique (pour info xargs prend ce qui arrive sur la sortie standard et passe cela comme options de la commande)

Il faut donc utiliser respectivement les options "-print0" de find et "-0" de xargs, ce qui permet à find de sortir des chaînes terminées par un caractères spécial ('\0', comme en C) et à xargs d'interpréter cela correctement...

find / -iname '*.mp3' -print0 | xargs -r -0 rm -f

3) échapper tous les espaces en utilisant des outils comme sed

Mais ça ne résoud pas le problème pour des tabulations ou des retours à la ligne dans les fichiers...

Lien vers le commentaire
Partager sur d’autres sites
lorinc Mentor

lorinc

Posté(e)
Posté(e)

enfin, cela dit, ça n'enlevera pas les mp3 qui sont nommés en *.dtc

si tu n'a pas beaucoup de répertoire où ces mp3 peuvent se cacher, tu peux faire un coup de file sur tous les fichiers et grep la chaine MPEG pour trouver ceux qui sont vraiment des mp3.

exemple gruiik : for i in $(find repertoire); do file $i; done | grep MPEG | cut -d ":" -f1

attention, ça peut être long et douloureux en calcul

;)

Lien vers le commentaire
Partager sur d’autres sites
16ar Collaborateur

16ar

Posté(e)
Posté(e)

D'ailleurs ca serait pas possible de faire un script utilisant fam pour vérifier directement si le fichier est un mp3 (a coup de file), ca serait moins douloureux en scan une fois que le filesystem est clean.

Mais bon, ca demandera un script plus évolué je pense (et je ne suis pas calé la dessus)

Lien vers le commentaire
Partager sur d’autres sites
tuXXX Expérimenté

tuXXX

Posté(e)
Posté(e)

Ça m'intéressait donc j'ai fait un petit programme en C ("watchdir.c") qui utilise inotify (c'est très simple et c'est efficace, par contre ça ne marche que sous linux>=2.6.13) et qui appelle un script à chaque fois qu'on ferme un fichier qui a été ouvert en écriture.

J'ai ensuite créé un petit script ("script.sh") pour tester ça.

Au final ça marche vraiment bien, quand on copie un fichier, à la fin de la copie inotify envoie un évènement au programme pour lui signaler qu'un fichier a été modifié, le programme appelle à son tour le script, qui vérifie avec des grep sur le nom et sur la sortie de la commande file et qui supprime le fichier si besoin.

Par contre, avec inotify, quand on monitore un dossier, ce n'est pas récursif, donc si on a plusieurs dossier à surveiller il faut lancer plusieurs fois l'exécutable (pas pratique du tout dans le contexte discuté dans ce topic).

Le plus simple serait alors de modifier le programme et de rajouter une détection de création et de suppression des dossiers avec inotify et de rajouter et retirer des watch par rapport à ça.

Le code n'est pas très long et ça peut potentiellement intéresser du monde, donc je poste ça :

watchdir.c

#include <stdio.h>	   /* printf(), perror() */
#include <stdlib.h>	  /* exit() */
#include <unistd.h>	  /* exec(), fork() */
#include <sys/wait.h>	/* waitpid() */
#include <sys/inotify.h> /* inotify_*() */

#define BUF_LEN 1024

void runscript(char *script, char *folder, char *file)
{
pid_t pid;
pid = fork();
switch(pid)
{
	case 0:
		execl(script, script, folder, file, NULL);
		perror("exec");
		break;
	case -1:
		perror("fork");
		break;
	default:
		waitpid(pid, NULL, 0);
		break;
}
}

int main(int argc, char **argv)
{
char buf[BUF_LEN];
int fd,wd;

if(argc <= 2)
{
	if(argc >= 1)
		printf("Usage : %s folder script\n", argv[0]);
	exit(1);
}

fd = inotify_init();
if(fd < 0)
{
	perror("inotify_init");
	exit(1);
}
wd = inotify_add_watch(fd, argv[1], IN_CLOSE_WRITE | IN_MOVED_TO);
if(wd < 0)
{
	perror("inotify_add_watch");
	exit(1);
}

int len;
while((len = read(fd, buf, BUF_LEN)) > 0)
{
	struct inotify_event *event = (struct inotify_event *)buf;

	printf("read %i\n", len);
	while(event < (struct inotify_event *)(buf+len))
	{
		if(wd == event->wd && event->len > 0)
		{
			printf("event = %X\n", event->mask);
			printf("name = %s (len=%i)\n", event->name, event->len);
			runscript(argv[2], argv[1], event->name);
		}
		event++;
	}
}

if(len < 1)
{
	perror("read");
	exit(1);
}

return 0;
}

script.sh

#!/bin/sh

if [ -z "$1" ] || [ -z "$2" ]
then
echo "Usage : $0 folder file"
exit 1
fi

FILE="$1/$2"

if ! [ -e "$FILE" ]
then
echo "$0 : \"$FILE\" : No such file or directory"
exit 1
fi

if ! [ -f "$FILE" ]
then
echo "$0 : \"$FILE\" : Not a file"
exit 1
fi

FILE_EXT="\.mp3$|\.avi$|\.mp[^.]g$|\.wmv$|\.mkv$|\.og[gm]$"
FILE_TYPE="MP3|Ogg|Vorbis|OGM|Matroska|MPEG|AVI|ASF|DivX|XviD"

detect()
{
echo "$1"	| grep -qiE "$FILE_EXT"  && return 0
file -- "$1" | grep -qE  "$FILE_TYPE" && return 0
return 1
}

echo ""
echo "-- script --"

if detect "$FILE"
then
echo "$FILE : Forbidden file detected, removing it!"
rm -f -- "$FILE"
fi

echo "------------"
echo ""

Lien vers le commentaire
Partager sur d’autres sites
Arofarn Collaborateur

Arofarn

Posté(e)
Posté(e)

Toi, je te jure que je connais des patrons qui vendraient père et mère pour t'embaucher... :fou:

P. Nègre :-D

J'aime le principe: si tu crée un fichier non-autoriser, il est effacé à peine créer :-D . Je connais des lycéens qui vont pester contre Windows :devil: (à tort pour une fois :devil: )

En dehors de ça, c'est super pratique comme petit utilitaire :transpi: : exécuter un script à la création/modification d'un fichier dans un répertoire... :devil:

Mais si j'ai bien compris ça ne prend pas en compte le contenu des sous-repertoire :zarb:

Lien vers le commentaire
Partager sur d’autres sites

Archivé

Ce sujet est désormais archivé et ne peut plus recevoir de nouvelles réponses.

Aller sur la liste des sujets
×
×
  • Créer...