Is there any asynchronous way to connect to an SFTP server?

I am working on an API that receives messages and uploads them to an SFTP server in a .json format. However, the connection time is taking too long, and the SFTP Connection takes over 1 second, which is too much.
I want to know if there is any way to connect to the server and send the file without waiting for so long.

I have thought about saving the files, answering the client, and then uploading the file with this method:

public async Task Upload(string localPath, string remotePath)
{
    await Task.Run(() =>
    {
        // upload code here
    });
}

However, if an exception occurs during the upload, the API might have already responded with an OK to the client, making it impossible to notify the client that the upload failed.

Here's the existing code that I am currently using to upload files:

public void Upload(string localPath, string remotePath)
{
    try
    {
        using (var sftp = new SftpClient(...))
            {
                sftp.Connect(); // Very slow
                sftp.UploadFile(...);
                sftp.Disconnect();
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error Upload SFTPHandler");
    }
}

Can someone suggest a solution to connect to the SFTP server and send the file without waiting for so long?

You can store the upload status, and do a separate check to see if it was uploaded. For example, you could cache the status in a ConcurrentDictionary. The client can then poll periodically for an upload status.

Assuming you are using the SSH.Net client, you can also use its asynchronous methods.

static ConcurrentDictionary<string, bool> _statuses = new();

[HttpPost]
public async Task UploadFile(string localPath, string remotePath)
{
    _statuses[remotePath] = false;
    Task.Run(() => Upload(localPath, remotePath));
}

private async Task Upload(string localPath, string remotePath)
{
    try
    {
        using var sftp = new SftpClient(...);
        sftp.ConnectAsync();
        await TaskFactory.FromAsync(
            (input, path, asyncCallback, state) =>
                sftp.BeginUploadFile(input, path, asyncCallback),
            sftp.EndUploadFile,
            ..., // some filestream
            remotePath,
            null);
        _statuses[remotePath] = true;
        sftp.Disconnect();
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error Upload SFTPHandler");
    }
}


[HttpPost]
public async Task<bool> IsUploaded(string remotePath)
{
    if (!_statuses.TryGetValue(remotePath, out var value))
    {
        // IIS was restarted.
        // check SFTP for finished upload.
        _statuses.Add(someStatus);
    }
    return value;
}

You may want to think about some way of caching the status in the event of an IIS server restart.

> However, if an exception occurs during the upload, the API might have already responded with an OK to the client, making it impossible to notify the client that the upload failed.

This is true for all "fire-and-forget" work, which is why it's often the wrong solution.

If you absolutely can't wait more than 1 second (?? doesn't sound too unreasonable to me), then your best option is a basic distributed architecture, as described on my blog. The basic distributed architecture has two parts, with an optional third part (which it sounds like you would want):

1. A durable queue. This is necessary to prevent the work from being lost.
2. A background process that processes the queue.
3. Client-side polling or notification to inform the client when the work completes.