it-swarm.com.de

Wie berechnet man die Größe des Verzeichnisses auf FTP?

Wie berechnet man die Größe des FTP-Ordners? Kennen Sie ein Programm oder einen programmatischen Weg in C #? 

26
jlp

Wenn Sie nur die Arbeit erledigen müssen, kann SmartFTP Ihnen helfen, es verfügt auch über ein PHP und ASP - Skript , um die Gesamtordnergröße durch rekursives Durchlaufen aller Dateien zu ermitteln.

4
zengr

Wenn Sie FileZilla haben, können Sie diesen Trick verwenden:

  • klicken Sie auf die Ordner, deren Größe Sie berechnen möchten
  • klicken Sie auf Add files to queue

Dadurch werden alle Ordner und Dateien geprüft und der Warteschlange hinzugefügt. Sehen Sie sich dann den Warteschlangenbereich an und darunter (in der Statusleiste) sollte eine Nachricht angezeigt werden, die die Warteschlangengröße angibt.

81
janusman

Sie können den Befehl du in lftp für diesen Zweck wie folgt verwenden:

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

Dadurch wird die Festplattengröße des aktuellen Verzeichnisses inkl. alle Unterverzeichnisse im lesbaren Format (-h) und ohne Ausgabezeilen für Unterverzeichnisse (-s). Die Ausgabe von stderr wird mit 2>&1 nach stdout umgeleitet, damit sie in die Ausgabe aufgenommen wird.

Allerdings ist lftp eine reine Linux-Software. Um sie von C # aus zu verwenden, müssten Sie sie in Cygwin verwenden.

Die lftp du-Befehlsdokumentation fehlt in seiner Manpage , ist jedoch in der lftp-Shell mit dem help du-Befehl verfügbar. Als Referenz kopiere ich die Ausgabe hier:

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
14
tanius

Sie können den Befehl LIST senden, der Ihnen eine Liste der Dateien im Verzeichnis sowie einige Informationen zu ihnen (ziemlich sicher, dass die Größe enthalten ist) enthält, die Sie dann analysieren und addieren können.

Kommt darauf an, wie Sie sich mit dem Server verbinden, aber wenn Sie die Klasse WebRequest.Ftp verwenden, gibt es die Methode ListDirectoryDetails. Siehe hier für Details und hier für Beispielcode.

Denken Sie nur daran, wenn Sie die Gesamtgröße einschließlich aller Unterverzeichnisse haben möchten, müssen Sie jedes Unterverzeichnis eingeben und rekursiv aufrufen, damit es ziemlich langsam werden kann. Es kann ziemlich langsam sein, also würde ich normalerweise empfehlen, wenn möglich, ein Skript auf dem Server die Größe berechnen lassen und das Ergebnis auf irgendeine Weise zurückgeben (möglicherweise in einer Datei speichern, die Sie herunterladen und lesen können).

Edit: Oder wenn Sie einfach nur meinen, dass Sie mit einem Tool zufrieden sind, das es für Sie erledigt, denke ich, dass FlashFXP es tut und wahrscheinlich auch andere fortgeschrittene FTP-Clients. Wenn es sich um einen Unix-Server handelt, habe ich ein vages Gedächtnis, in das Sie sich einfach einloggen und ls -laR oder etwas eingeben können, um eine rekursive Verzeichnisliste zu erhalten.

2
Hans Olsson

Ich benutze die FTPS-Bibliothek von Alex Pilotti mit C #, um einige FTP-Befehle in einigen Produktionsumgebungen auszuführen. Die Bibliothek funktioniert gut, aber Sie müssen rekursiv eine Liste der Dateien im Verzeichnis abrufen und ihre Größen addieren, um das Ergebnis zu erhalten. Dies kann auf einigen unserer größeren Server (manchmal 1-2 Minuten) mit komplexen Dateistrukturen etwas zeitaufwändig sein. 

Wie auch immer, das ist die Methode, die ich mit seiner Bibliothek benutze:

/// <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;
}
1
jsmith

Einfachste und effizientere Methode, um die FTP-Verzeichnisgröße mit allen Inhalten rekursiv abzurufen.

var size = FtpHelper.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 FtpHelper
{
    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.
            //Get size of selected directory and add it to overall directory size.
            Parallel.ForEach(subDirectoriesList, (subDirectory) => //Loop on every directory
        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
                while (!string.IsNullOrEmpty(line = streamReader.ReadLine())) //Read current line of Stream.
                    directoryContents.Add(line); //Add current line to Directory Contentss List.
            }
        }
        catch (Exception) { throw; } //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);
    }
}
1
Ahmed Sabry