Come calcolare la dimensione della directory su FTP?

Question

Come calcolare la dimensione della cartella FTP? Conosci qualche strumento o modo programmatico in C#?

Answer 1

Se hai solo bisogno di lavoro, SmartFTP potrebbe aiutarti, it also has a PHP and ASP script per ottenere le dimensioni totali della cartella passando in modo ricorsivo attraverso tutti i file.

Answer 2

È possibile inviare il comando LIST che dovrebbe fornire un elenco di file nella directory e alcune informazioni su di essi (abbastanza certa la dimensione è inclusa), che è quindi possibile analizzare e aggiungere.

Dipende da come ci si connette al server, ma se si sta utilizzando la classe WebRequest.Ftp è disponibile il metodo ListDirectoryDetails. Vedere here per i dettagli e here per alcuni codici di esempio.

Basta essere consapevoli, se si desidera avere le dimensioni totali comprese tutte le sottodirectory, penso che dovrete inserire ciascuna sottodirectory e chiamarla in modo ricorsivo in modo che potrebbe essere piuttosto lento. Può essere un po 'lento, quindi di solito raccomandavo, se possibile, di avere uno script sul server che calcolasse la dimensione e restituisse il risultato in qualche modo (eventualmente memorizzandolo in un file che potevi scaricare e leggere).

Modifica: O se vuoi dire che sarai felice con uno strumento che fa al posto tuo, penso che FlashFXP lo faccia e probabilmente anche altri client FTP avanzati. O se si tratta di un server Unix, ho una vaga memoria che è sufficiente accedere e digitare ls -laR o qualcosa per ottenere un elenco di directory ricorsivo.

Answer 3

Basta usare FTP comando "SIZE" ...

Answer 4

Se si dispone di FileZilla, è possibile utilizzare questo trucco:

• clic sulla cartella (s) di cui si vuole calcolare
dimensioni
• fare clic su Add files to queue

Questa scansione di tutte le cartelle e file e li aggiunge alla coda. Quindi guarda il pannello della coda e sotto di esso (sulla barra di stato) dovresti vedere un messaggio che indica la dimensione della coda.

Answer 5

Io uso il FTPS library da Alex Pilotti con C# per eseguire alcuni comandi FTP in alcuni ambienti di produzione. La libreria funziona bene, ma devi ottenere in modo ricorsivo un elenco di file nella directory e aggiungere le loro dimensioni per ottenere il risultato. Questo può richiedere un po 'di tempo su alcuni dei nostri server più grandi (a volte 1-2 minuti) con strutture di file complesse.

In ogni caso, questo è il metodo che uso con la sua biblioteca:

/// <summary> 
/// <para>This will get the size for a directory</para> 
/// <para>Can be lengthy to complete on complex folder structures</para> 
/// </summary> 
/// <param name="pathToDirectory">The path to the remote directory</param> 
public ulong GetDirectorySize(string pathToDirectory) 
{ 
    try 
    { 
     var client = Settings.Variables.FtpClient; 
     ulong size = 0; 

     if (!IsConnected) 
      return 0; 

     var dirList = client.GetDirectoryList(pathToDirectory); 
     foreach (var item in dirList) 
     { 
      if (item.IsDirectory) 
       size += GetDirectorySize(string.Format("{0}/{1}", pathToDirectory, item.Name)); 
      else 
       size += item.Size; 
     } 
     return size; 
    } 
    catch (Exception ex) 
    { 
     Console.WriteLine(ex.Message); 
    } 
    return 0; 
} 

Answer 6

È possibile utilizzare il comando du in lftp per questo scopo, come questo:

echo "du -hs ." | lftp example.com 2>&1 

Questo stamperà la corrente dimensione del disco della directory incl. tutte le sottodirectory, in formato leggibile dall'uomo (-h) e omettendo le righe di output per le sottodirectory (-s). l'output di stderr viene reindirizzato allo stdout con 2>&1 in modo che sia incluso nell'output.

Tuttavia, lftp è un software solo per Linux, quindi per utilizzarlo da C# è necessario utilizzarlo entro Cygwin.

La documentazione di comando lftp du manca da its manpage, ma è disponibile all'interno della shell lftp con il comando help du. Per avere un riferimento, copio la sua uscita qui:

lftp :~> help du 
Usage: du [options] <dirs> 
Summarize disk usage. 
-a, --all    write counts for all files, not just directories 
    --block-size=SIZ use SIZ-byte blocks 
-b, --bytes   print size in bytes 
-c, --total   produce a grand total 
-d, --max-depth=N  print the total for a directory (or file, with --all) 
         only if it is N or fewer levels below the command 
         line argument; --max-depth=0 is the same as 
         --summarize 
-F, --files   print number of files instead of sizes 
-h, --human-readable print sizes in human readable format (e.g., 1K 234M 2G) 
-H, --si    likewise, but use powers of 1000 not 1024 
-k, --kilobytes  like --block-size=1024 
-m, --megabytes  like --block-size=1048576 
-S, --separate-dirs do not include size of subdirectories 
-s, --summarize  display only a total for each argument 
    --exclude=PAT  exclude files that match PAT 

Answer 7

più semplice e modo efficiente per ottenere Directory FTP Size con i suoi tutti i contenuti in modo ricorsivo.

var size = FTP.GetFtpDirectorySize ("ftpURL", "userName", "password");

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Net; 
using System.Threading; 
using System.Threading.Tasks; 

public static class FTP 
{ 
    public static long GetFtpDirectorySize(Uri requestUri, NetworkCredential networkCredential, bool recursive = true) 
    { 
     //Get files/directories contained in CURRENT directory. 
     var directoryContents = GetFtpDirectoryContents(requestUri, networkCredential); 

     long ftpDirectorySize = default(long); //Set initial value of the size to default: 0 
     var subDirectoriesList = new List<Uri>(); //Create empty list to fill it later with new founded directories. 

     //Loop on every file/directory founded in CURRENT directory. 
     foreach (var item in directoryContents) 
     { 
      //Combine item path with CURRENT directory path. 
      var itemUri = new Uri(Path.Combine(requestUri.AbsoluteUri + "\\", item)); 
      var fileSize = GetFtpFileSize(itemUri, networkCredential); //Get item file size. 

      if (fileSize == default(long)) //This means it has no size so it's a directory and NOT a file. 
       subDirectoriesList.Add(itemUri); //Add this item Uri to subDirectories to get it's size later. 
      else //This means it has size so it's a file. 
       Interlocked.Add(ref ftpDirectorySize, fileSize); //Add file size to overall directory size. 
     } 

     if (recursive) //If recursive true: it'll get size of subDirectories files. 
      Parallel.ForEach(subDirectoriesList, (subDirectory) => //Loop on every directory 
      //Get size of selected directory and add it to overall directory size. 
     Interlocked.Add(ref ftpDirectorySize, GetFtpDirectorySize(subDirectory, networkCredential, recursive))); 

     return ftpDirectorySize; //returns overall directory size. 
    } 
    public static long GetFtpDirectorySize(string requestUriString, string userName, string password, bool recursive = true) 
    { 
     //Initialize Uri/NetworkCredential objects and call the other method to centralize the code 
     return GetFtpDirectorySize(new Uri(requestUriString), GetNetworkCredential(userName, password), recursive); 
    } 

    public static long GetFtpFileSize(Uri requestUri, NetworkCredential networkCredential) 
    { 
     //Create ftpWebRequest object with given options to get the File Size. 
     var ftpWebRequest = GetFtpWebRequest(requestUri, networkCredential, WebRequestMethods.Ftp.GetFileSize); 

     try { return ((FtpWebResponse)ftpWebRequest.GetResponse()).ContentLength; } //Incase of success it'll return the File Size. 
     catch (Exception) { return default(long); } //Incase of fail it'll return default value to check it later. 
    } 
    public static List<string> GetFtpDirectoryContents(Uri requestUri, NetworkCredential networkCredential) 
    { 
     var directoryContents = new List<string>(); //Create empty list to fill it later. 
                //Create ftpWebRequest object with given options to get the Directory Contents. 
     var ftpWebRequest = GetFtpWebRequest(requestUri, networkCredential, WebRequestMethods.Ftp.ListDirectory); 
     try 
     { 
      using (var ftpWebResponse = (FtpWebResponse)ftpWebRequest.GetResponse()) //Excute the ftpWebRequest and Get It's Response. 
      using (var streamReader = new StreamReader(ftpWebResponse.GetResponseStream())) //Get list of the Directory Contentss as Stream. 
      { 
       var line = string.Empty; //Initial default value for line. 
       do 
       { 
        line = streamReader.ReadLine(); //Read current line of Stream. 
        directoryContents.Add(line); //Add current line to Directory Contentss List. 
       } while (!string.IsNullOrEmpty(line)); //Keep reading while the line has value. 
      } 
     } 
     catch (Exception) { } //Do nothing incase of Exception occurred. 
     return directoryContents; //Return all list of Directory Contentss: Files/Sub Directories. 
    } 
    public static FtpWebRequest GetFtpWebRequest(Uri requestUri, NetworkCredential networkCredential, string method = null) 
    { 
     var ftpWebRequest = (FtpWebRequest)WebRequest.Create(requestUri); //Create FtpWebRequest with given Request Uri. 
     ftpWebRequest.Credentials = networkCredential; //Set the Credentials of current FtpWebRequest. 

     if (!string.IsNullOrEmpty(method)) 
      ftpWebRequest.Method = method; //Set the Method of FtpWebRequest incase it has a value. 
     return ftpWebRequest; //Return the configured FtpWebRequest. 
    } 
    public static NetworkCredential GetNetworkCredential(string userName, string password) 
    { 
     //Create and Return NetworkCredential object with given UserName and Password. 
     return new NetworkCredential(userName, password); 
    } 
}