Quantidade massiva de subpastas e subpastas longas. Como posso deletar todos eles?

2

Temos um pequeno problema aqui.

Temos um compartilhamento com o backup de todos os escritórios do servidor. É uma grande participação com mais de 8.000.000 de arquivos.

Nossos usuários geralmente dão nomes longos às pastas que eles criam, e então criam subpastas (longas também) e mais subpastas ... e mais sub-portadores ...

Temos um novo compartilhamento com mais capacidade e, com um bastão robocopy simpe, copiamos todos os arquivos e pastas (alguns dão problemas, mas os copiamos manualmente)

Mas o problema é excluí-los . del command didnt funcionou bem quando caminhos tão longos, neirder rmdir ... Eu tentei alguns comandantes, mas sem sorte.

Você pode me recomendar qualquer ferramenta que possa ser excluída recursivamente ou capaz de excluir mais de 255 caminhos?

Editado: O SO no plano de fundo do compartilhamento é o NetApp OS. Mas eu posso acessá-lo a partir do Windows Servers. 2000 e 2003

Obrigado.

Solução não perfeita, mas que funciona

Aqui está o script no Windows Scripting que eu faço para resolver o problema. Não é perfeito, mas se alguém tiver o mesmo problema, pode usá-lo.

Option Explicit 
DIM strFolder
DIM objFSO

' ************************************************************
' Setup
' ************************************************************
' Folder to delete files from (files will also be deleted from subfolders)
strFolder = "Z:\del"
' ************************************************************
set objFSO = createobject("Scripting.FileSystemObject")

Wscript.echo "Processing " & strFolder
RecursiveDeleteByExtension strFolder

wscript.echo "Finished"

sub RecursiveDeleteByExtension(byval strDirectory)
    DIM objFolder, objSubFolder, objFile, Tmp, Indice

    set objFolder = objFSO.GetFolder(strDirectory)

    Wscript.echo "Processing " & strDirectory

    for each objFile in objFolder.Files
        WScript.echo "Deleting:" & objFile.Path
        objFile.Delete
    next    
    Indice = 0
    For each objSubFolder in objFolder.SubFolders
        If Len (objSubFolder.Name) > 5 Then
            Indice = Indice + 1
            objSubFolder.Move(objFolder.Path & "\" & Indice & ".t")
        End if
    Next

    for each objSubFolder in objFolder.SubFolders
        RecursiveDeleteByExtension objSubFolder.Path
    Next
    objFSO.DeleteFolder(strDirectory)
end sub

O que este script faz, recursivamente, é mudar um caminho muito longo como \ bla ... \ bla ... \ bla ... \ bla ... para um muito mais curto \ 1 \ 2 \ 1 \ 2 \ e após a renomeação no final de cada recursão, exclui a pasta do objeto (quem está vazio, btw).

Trabalha muito bem para mim, mesmo assim encontramos caminhos completos perto de 200 caracteres (imagine com antes do script).

    
por Carlos Garcia 02.02.2011 / 13:23

7 respostas

2

Este é um programa dot_deltree.cs em C # que exclui árvores de diretórios de qualquer profundidade. Ele funciona primeiro movendo diretórios muito profundos para nomes aleatórios no diretório mais superficial.

using System;
using System.IO;

public class dot_deltree
{
    public static void Main(string[] args) {
        if ( ! (args.Length == 1) ) {
            Console.Error.WriteLine("Usage: dot_deltree [path]");
            Environment.Exit(1);
        }

        string dirname = args[0];

        if ( ! Directory.Exists(dirname) ) {
            Console.Error.WriteLine("{0} does not exist or is not a directory!", dirname);
            Environment.Exit(1);
        }

        confirm_deleting(dirname);

        while ( true ) {
            string too_deep_dir = deltree( dirname );
            if ( too_deep_dir.Equals("") ) {
                break;
            }
            string randomname = Path.GetRandomFileName();
            Console.Error.WriteLine(
                "Moving too deep directory {0}:{2} to random name {1}", 
                too_deep_dir, randomname, too_deep_dir.Length
            );
            Directory.Move( too_deep_dir, Path.Combine(dirname,randomname) );
        }
    }

    public static void confirm_deleting(string path) {
        Console.Write("Do you really want do delete directory {0} recursively (type YES)? ", path);
        string result = Console.ReadLine();
        if ( ! result.Equals("YES") ) {
            Environment.Exit(1);
        }
    }

    public static string deltree(string uncpath) {
        if ( uncpath.Length > 200 ) {
            return uncpath;
        }
        string[] subdirectories = Directory.GetDirectories(uncpath);
        foreach (string subdirectory in subdirectories) {
            string result = deltree(subdirectory);
            if ( ! result.Equals("") ) {
                // Return up too deep directory
                return result;
            }
        }
        // Console.Error.WriteLine("Deleting {0}", uncpath);
        Directory.Delete(uncpath,true);
        return "";
    }
}

Compilado usando o compilador Mono C # usando gmcs dot_deltree.cs para .NET 2.0 é aqui (4kb) .

    
por 02.02.2011 / 20:00
1

tente para / f "delims="% a em ('dir / ad / b') do rm / s / q "% a" - ele irá recursivamente e sem pedir excluir todos os subdiretórios do diretório atual listados na saída dir / ad / b

    
por 02.02.2011 / 14:41
1

Se esse compartilhamento for a única coisa em uma partição, seria mais fácil reformatá-lo.

Se houver algo que vale a pena salvar na partição, basta copiá-la em algum lugar, reformatá-la e copiá-la de volta.

    
por 02.02.2011 / 15:33
0

Tente usar "deltree". Estou no linux apenas agora, mas eu recomendo fazer um "deltree /?" primeiro!

    
por 02.02.2011 / 14:22
0

Você já tentou WinDirStat Eu não tenho certeza sobre o limite 255 como ele emite comandos do Windows para fazer a exclusão, mas pode ajudá-lo a resolver a bagunça mais fácil.

Ferramenta muito útil em contrário

    
por 02.02.2011 / 14:41
0

O que acontece se você usar a opção Robocopy / Move? Isso excluirá os arquivos da fonte após a cópia.

    
por 02.02.2011 / 15:25
0

E se você usou ROBOCOPY com o sinal /MIR para espelhar uma pasta vazia sobre os arquivos indesejados? Se for inteligente o suficiente para copiar arquivos com nomes longos, deve ser inteligente o suficiente para excluí-los.

 MKDIR empty
 ROBOCOPY empty <dest> /MIR

Além disso, é possível que isso não chegue mais longe do que a sugestão de Chris.

    
por 03.02.2011 / 10:47