Comment calculer la taille du répertoire sur FTP?

Question

Comment calculer la taille du dossier FTP? Connaissez-vous un outil ou une méthode programmatique en C#?

Answer 1

Si vous avez juste besoin de faire le travail, alors SmartFTP peut vous aider, it also has a PHP and ASP script, à obtenir la taille totale du dossier en parcourant récursivement tous les fichiers.

Answer 2

Vous pouvez envoyer la commande LIST qui devrait vous donner une liste de fichiers dans le répertoire et quelques informations à leur sujet (à peu près certain que la taille est incluse), que vous pourriez ensuite analyser et ajouter.

Dépend de la façon dont vous vous connectez au serveur, mais si vous utilisez la classe WebRequest.Ftp, il existe la méthode ListDirectoryDetails pour cela. Voir here pour les détails et here pour un exemple de code. Sachez que si vous voulez avoir la taille totale incluant tous les sous-répertoires, je pense que vous devrez entrer chaque sous-répertoire et l'appeler récursivement pour qu'il soit assez lent. Cela peut être assez lent, alors normalement, j'ai recommandé, si possible, d'avoir un script sur le serveur pour calculer la taille et renvoyer le résultat d'une certaine façon (en le stockant dans un fichier que vous pourriez télécharger et lire).

Editer: Ou si vous voulez juste dire que vous seriez content d'un outil qui le fait pour vous, je pense que FlashFXP le fait et probablement d'autres clients FTP avancés aussi. Ou si c'est un serveur Unix j'ai un vague souvenir que vous pouvez simplement vous connecter et tapez ls -laR ou quelque chose pour obtenir une liste récursive du répertoire.

Answer 3

Il suffit d'utiliser la commande FTP "SIZE" ...

Answer 4

Si vous avez FileZilla, vous pouvez utiliser cette astuce:

• cliquez sur le dossier (s) dont la taille que vous voulez calculer
• cliquez sur Add files to queue

Ceci va scanner tous les dossiers et fichiers et les ajouter à la file d'attente. Ensuite, regardez dans le volet de file d'attente et en dessous (sur la barre d'état), vous devriez voir un message indiquant la taille de la file d'attente.

Answer 5

J'utilise le FTPS library d'Alex Pilotti avec C# pour exécuter certaines commandes FTP dans quelques environnements de production. La bibliothèque fonctionne bien, mais vous devez récursivement obtenir une liste de fichiers dans le répertoire et ajouter leurs tailles ensemble pour obtenir le résultat. Cela peut prendre un peu de temps sur certains de nos plus gros serveurs (parfois 1-2 min) avec des structures de fichiers complexes.

Quoi qu'il en soit, c'est la méthode que je l'utilise avec sa bibliothèque:

/// <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

Vous pouvez utiliser la commande du dans lftp à cet effet, comme ceci:

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

Cela affichera le courant taille du disque du répertoire incl. tous les sous-répertoires, dans un format lisible par l'homme (-h) et en omettant les lignes de sortie pour les sous-répertoires (-s). La sortie stderr est redirigée vers stdout avec 2>&1 afin qu'elle soit incluse dans la sortie.

Toutefois, lftp est un logiciel Linux uniquement, donc pour l'utiliser à partir de C#, vous devez l'utiliser dans Cygwin.

La documentation de la commande lftp du est manquante dans its manpage, mais disponible dans le shell lftp avec la commande help du. Pour référence, je copie ici sa sortie:

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

plus simple et efficace pour obtenir FTP Directory Size avec elle est tout le contenu récursive.

var size = FTP.GetFtpDirectorySize ("ftpURL", "nomUtilisateur", "mot de passe");

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); 
    } 
}