📚 Référence API

🖥️ API CLI (Ligne de Commande)

L'outil en ligne de commande utilise System.CommandLine pour le parsing des arguments.

sftp-copy-tool [options]

sftp-copy-tool \
  --host sftp.example.com \
  --port 22 \
  --username admin \
  --password "secret123" \
  --remote-path /data/backup \
  --local-path /mnt/nas/backup \
  --recursive \
  --log-level Debug

🌐 Services Web

L'application Blazor expose plusieurs services pour gérer les opérations SFTP et l'interface utilisateur.

SftpExecutionService

Service principal pour exécuter les opérations SFTP avec suivi de progression.

public async Task ExecuteAsync(
    string host,
    int port,
    string username,
    string password,
    string remotePath,
    string localPath,
    bool recursive,
    IProgressReporter progressReporter,
    CancellationToken cancellationToken
)

📡 SftpService

Service bas niveau pour les opérations SFTP utilisant la bibliothèque Tmds.Ssh.

public async Task CopyFileAsync(
    string host,
    int port,
    string username,
    string password,
    string remotePath,
    string localPath,
    IProgress<ProgressInfo>? progress = null
)

public class ProgressInfo
{
    public long BytesTransferred { get; set; }
    public long TotalBytes { get; set; }
    public double Percentage { get; set; }
    public double SpeedBytesPerSecond { get; set; }
    public TimeSpan Elapsed { get; set; }
    public TimeSpan? EstimatedRemaining { get; set; }
    public string CurrentFile { get; set; }
}

public async Task CopyDirectoryRecursiveAsync(
    string host,
    int port,
    string username,
    string password,
    string remotePath,
    string localPath,
    IProgress<ProgressInfo>? progress = null
)

public async Task<bool> TestConnectionAsync(
    string host,
    int port,
    string username,
    string password
)

📊 Suivi de Progression

IProgressReporter Interface

public interface IProgressReporter
{
    void Report(ProgressInfo info);
    void AddLog(string message);
    IReadOnlyList<string> GetRecentLogs();
}

var progressReporter = new ProgressReporter();
progressReporter.OnProgressChanged = (info) =>
{
    Console.WriteLine($"Progression: {info.Percentage:F1}%");
    Console.WriteLine($"Vitesse: {info.SpeedBytesPerSecond / 1024:F2} KB/s");
};

await sftpService.CopyFileAsync(
    "sftp.example.com", 22, "user", "pass",
    "/remote/file.zip", "/local/dest/",
    new Progress<ProgressInfo>(progressReporter.Report)
);

📁 Explorateur de Fichiers

FileExplorerService

public async Task<List<FileEntry>> ListRemoteDirectoryAsync(
    string host,
    int port,
    string username,
    string password,
    string remotePath
)

public class FileEntry
{
    public string Name { get; set; }
    public string FullPath { get; set; }
    public bool IsDirectory { get; set; }
    public long Size { get; set; }
    public DateTime? LastModified { get; set; }
}

public async Task<List<FileEntry>> ListLocalDirectoryAsync(
    string localPath
)

⚠️ Gestion des Erreurs

Types d'Exceptions

Messages d'Erreur Courants

Gestion des Erreurs dans le Code

try
{
    await sftpService.CopyFileAsync(
        host, port, username, password,
        remotePath, localPath, progress
    );
    Console.WriteLine("✅ Transfert réussi");
}
catch (SshException ex)
{
    Console.WriteLine($"❌ Erreur SFTP: {ex.Message}");
    // Vérifier connexion réseau, identifiants
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine($"❌ Permissions refusées: {ex.Message}");
    // Vérifier permissions du dossier local
}
catch (IOException ex)
{
    Console.WriteLine($"❌ Erreur E/S: {ex.Message}");
    // Vérifier espace disque, chemin valide
}
catch (Exception ex)
{
    Console.WriteLine($"❌ Erreur inattendue: {ex.Message}");
    // Logger pour investigation
}

📖 Exemples Complets

Exemple 1: Transfert Simple avec Progression

using SftpCopyTool;

var sftpService = new SftpService();
var progress = new Progress<ProgressInfo>(info =>
{
    Console.WriteLine($"📊 {info.Percentage:F1}% | " +
                      $"⚡ {info.SpeedBytesPerSecond / 1024:F2} KB/s | " +
                      $"📁 {info.CurrentFile}");
});

try
{
    await sftpService.CopyFileAsync(
        "sftp.example.com",
        22,
        "admin",
        "password123",
        "/remote/file.tar.gz",
        "/local/backup/",
        progress
    );
    Console.WriteLine("✅ Transfert terminé avec succès!");
}
catch (Exception ex)
{
    Console.WriteLine($"❌ Erreur: {ex.Message}");
}

Exemple 2: Interface Web - Composant Blazor

@page "/copy"
@inject SftpExecutionService SftpService

<h3>SFTP Copy Tool</h3>

<EditForm Model="@model" OnValidSubmit="@StartCopy">
    <InputText @bind-Value="model.Host" placeholder="Host" />
    <InputNumber @bind-Value="model.Port" placeholder="Port" />
    <InputText @bind-Value="model.Username" placeholder="Username" />
    <InputText type="password" @bind-Value="model.Password" placeholder="Password" />
    <InputText @bind-Value="model.RemotePath" placeholder="Remote Path" />
    <InputText @bind-Value="model.LocalPath" placeholder="Local Path" />
    <InputCheckbox @bind-Value="model.Recursive" /> Recursive

    <button type="submit">Start Copy</button>
</EditForm>

@if (progress != null)
{
    <div>
        <p>Progression: @progress.Percentage.ToString("F1")%</p>
        <p>Vitesse: @(progress.SpeedBytesPerSecond / 1024).ToString("F2") KB/s</p>
        <p>Fichier: @progress.CurrentFile</p>
    </div>
}

@code {
    private SftpModel model = new();
    private ProgressInfo? progress;
    private CancellationTokenSource? cts;

    private async Task StartCopy()
    {
        cts = new CancellationTokenSource();
        var progressReporter = new ProgressReporter();
        progressReporter.OnProgressChanged = (info) =>
        {
            progress = info;
            StateHasChanged();
        };

        try
        {
            await SftpService.ExecuteAsync(
                model.Host, model.Port, model.Username, model.Password,
                model.RemotePath, model.LocalPath, model.Recursive,
                progressReporter, cts.Token
            );
        }
        catch (Exception ex)
        {
            // Handle error
        }
    }
}