build - recursivo - eliminar directorio linux sin confirmacion

Unix: rápido ''eliminar directorio'' para limpiar construcciones diarias

Question

¿Hay una manera más rápida de eliminar un directorio que simplemente enviando

rm -r -f *directory*

? Lo pregunto porque nuestras compilaciones multiplataforma diarias son realmente enormes (por ejemplo, 4 GB por compilación). Así que los discos duros en algunas de las máquinas a menudo se están quedando sin espacio.

Este es el caso de nuestras plataformas AIX y Solaris.

¿Quizás hay comandos ''especiales'' para eliminar directorios en estas plataformas?

PASTE-EDITAR (movió mi propia respuesta por separado a la pregunta):

En general, me pregunto por qué ''rm -r -f'' es tan lento. ¿No ''rm'' solo necesita modificar el ''..'' o ''.'' Archivos para desasignar las entradas del sistema de archivos.

algo como

mv *directory* /dev/null

sería bueno.

Answer 1

Al menos en AIX, debería estar usando LVM, el administrador de volúmenes lógicos. Todos nuestros sistemas agrupan todo el disco duro físico en un solo grupo de volúmenes y luego crean un gran sistema de archivos de ese tipo.

De esa manera, puede agregar dispositivos físicos a su máquina a voluntad y aumentar el tamaño de su sistema de archivos a lo que necesite.

Otra solución que he visto es asignar un directorio de basura en cada sistema de archivos y usar una combinación de mv y un trabajo cron find para abordar el problema del espacio.

Básicamente, tiene un trabajo cron que se ejecuta cada diez minutos y ejecuta:

rm -rf /trash/*
rm -rf /filesys1/trash/*
rm -rf /filesys2/trash/*

Luego, cuando quiera que su directorio específico en ese sistema de archivos sea reciclado, use algo como:

mv /filesys1/overnight /filesys1/trash/overnight

y, dentro de los próximos diez minutos, su espacio en disco comenzará a recuperarse. El directorio filesys1/overnight estará inmediatamente disponible para su uso incluso antes de que la versión eliminada haya comenzado a eliminarse.

Es importante que el directorio de la papelera esté en el mismo sistema de archivos que el directorio del que quiere deshacerse, de lo contrario, tendrá en sus manos una operación de copia / eliminación masiva en lugar de un movimiento relativamente rápido.

Answer 2

Codifiqué una pequeña aplicación Java RdPro (herramienta de depuración de directorios recursiva) que es más rápida que rm. También puede eliminar los directorios de destino especificados por el usuario bajo una raíz. Funciona tanto para Linux / Unix como para Windows. Tiene una versión de línea de comandos y una versión de GUI.

https://github.com/mhisoft/rdpro

Answer 3

En Solaris, esta es la forma más rápida que he encontrado.

find /dir/to/clean -type f|xargs rm

Si tiene archivos con rutas impares, use

find /dir/to/clean -type f|while read line; do echo "$line";done|xargs rm 

Answer 4

Olvidé la fuente de este truco pero funciona:

EMPTYDIR=$(mktemp -d)
rsync -r --delete $EMPTYDIR/ dir_to_be_emptied/

Answer 5

Para eliminar un directorio de un sistema de archivos, rm es su opción más rápida. En Linux, a veces hacemos nuestras compilaciones (algunos GB) en un disco RAM, y tiene una velocidad de eliminación realmente impresionante :) También puedes probar diferentes sistemas de archivos, pero en AIX / Solaris puede que no tengas muchas opciones ...

Si su objetivo es tener el directorio $ dir vacío ahora , puede cambiarle el nombre y eliminarlo más tarde de un trabajo de fondo / cron:

mv "$dir" "$dir.old"
mkdir "$dir"
# later
rm -r -f "$dir.old"

Otro truco es que crea un sistema de archivos separado para $ dir, y cuando desea eliminarlo, simplemente vuelva a crear el sistema de archivos. Algo como esto:

# initialization
mkfs.something /dev/device
mount /dev/device "$dir"


# when you want to delete it:
umount "$dir"
# re-init
mkfs.something /dev/device
mount /dev/device "$dir"

Answer 6

Pienso que en realidad no hay nada más que "rm -rf" como citó para eliminar sus directorios.

para evitar hacerlo manualmente una y otra vez, puede programar diariamente un script que elimine recursivamente todos los directorios de compilación de su directorio raíz de compilación si son "suficientemente antiguos" con algo como:

find <buildRootDir>/* -prune -mtime +4 -exec rm -rf {} /;

(aquí mtime +4 indica "cualquier archivo anterior a 4 días)

Otra forma sería configurar su constructor (si permite tales cosas) para aplastar la compilación anterior con la actual.

Answer 7

Se necesita eliminar 700 Gbytes de docenas de directorios en el disco AWS EBS de 1 TB (ext3) antes de copiar el resto en un nuevo volumen XFS de 200 Gbyte. Tomaba horas dejando ese volumen al 100% wa. Como el tiempo de E / S del disco y el tiempo del servidor no son libres, esto tomó solo una fracción de segundo por directorio.

donde / dev / sdb es un volumen vacío de cualquier tamaño

directory_to_delete = / ebs / var / tmp /

mount / dev / sdb $ directory_to_delete

nohup rsync -avh / ebs / / ebs2 /

Answer 8

Si rm -rf es lento, quizás esté usando una opción de "sincronización" o similar, que está escribiendo en el disco con demasiada frecuencia. En Linux ext3 con opciones normales, rm -rf es muy rápido.

Una opción para la eliminación rápida que funcionaría en Linux y presumiblemente también en varios Unixen es usar un dispositivo de bucle, algo como:

hole temp.img $[5*1024*1024*1024]  # create a 5Gb "hole" file
mkfs.ext3 temp.img
mkdir -p mnt-temp
sudo mount temp.img mnt-temp -o loop

El programa "agujero" es uno que escribí yo mismo para crear un gran archivo vacío utilizando un "agujero" en lugar de bloques asignados en el disco, que es mucho más rápido y no utiliza ningún espacio en disco hasta que realmente lo necesite. http://sam.nipl.net/coding/c-examples/hole.c

Acabo de notar que GNU coreutils contiene un programa similar "truncar", así que si tienes eso, puedes usarlo para crear la imagen:

truncate --size=$[5*1024*1024*1024] temp.img

Ahora puede usar la imagen montada en mnt-temp para almacenamiento temporal, para su compilación. Cuando haya terminado con esto, haga esto para eliminarlo:

sudo umount mnt-temp
rm test.img
rmdir mnt-temp

¡Creo que encontrarás que eliminar un solo archivo grande es mucho más rápido que eliminar muchos pequeños archivos!

Si no te importa compilar mi programa "hole.c", puedes usar dd, pero esto es mucho más lento:

dd if=/dev/zero of=temp.img bs=1024 count=$[5*1024*1024]  # create a 5Gb allocated file

Answer 9

Tuve que borrar más de 3,00,000 archivos en windows. Tuve Cygwin instalado. Por suerte tenía todo el directorio primario en una base de datos. Creó un bucle for y se basó en la entrada de línea y eliminó usando rm -rf

Answer 10

Use perl -e ''para (<*>) {((stat) [9] <(unlink))}'' Consulte el siguiente enlace: http://www.slashroot.in/which-is-the-fastest-method-to-delete-files-in-linux

Answer 11

Yo también estaba investigando esto.

Tuve un directorio con más de 600,000 archivos.

rm * fallaría, porque hay demasiadas entradas.

find . -exec rm {} /; fue agradable, y eliminar ~ 750 archivos cada 5 segundos. Estaba comprobando la tasa rm a través de otro shell.

Entonces, en lugar de eso, escribí un script corto para grabar muchos archivos a la vez. Que obtuvo unos ~ 1000 archivos cada 5 segundos. La idea es poner tantos archivos en el comando 1 rm como puedas para aumentar la eficiencia.

#!/usr/bin/ksh
string="";
count=0;
for i in $(cat filelist);do
    string="$string $i";
    count=$(($count + 1));
  if [[ $count -eq 40 ]];then
    count=1;
    rm $string
    string="";
  fi
done

Answer 12

rm -r directory funciona recursivando primero la profundidad a través del directorio , eliminando archivos y eliminando los directorios en la copia de seguridad. Tiene que hacerlo, ya que no puede eliminar un directorio que no esté vacío.

Detalles largos y aburridos: cada objeto del sistema de archivos está representado por un inodo en el sistema de archivos, que tiene una serie de inodos planos en todo el sistema de archivos. [1] Si acaba de eliminar el directorio sin eliminar primero sus hijos, los hijos permanecerán asignados, pero sin ningún indicador de ellos. ( fsck comprueba ese tipo de cosas cuando se ejecuta, ya que representa un daño del sistema de archivos.)

[1] Es posible que esto no sea estrictamente cierto para todos los sistemas de archivos existentes, y puede haber un sistema de archivos que funcione de la forma que usted describe. Posiblemente requeriría algo como un recolector de basura. Sin embargo, todos los objetos comunes que conozco actúan como si los objetos fs fueran propiedad de inodes, y los directorios son listas de pares de nombre / número de inode.