Simplified API around IFtpClient

Author: fubar-coder

samples/FtpServer/FtpServerService.cs

@@ -123,20 +123,27 @@ private async Task ExecuteClientAsync(
  {
  await using var registration = cancellationToken.Register(
  connectionContext.Abort);
- var client = await _clientFactory.CreateClientAsync(connectionContext, cancellationToken);
- var clientInfo = new FtpClientInformation(client, connectionContext);
- lock (_activeClientsLock)
+ try
  {
- _activeClients = _activeClients.Add(clientInfo);
- }
+ var client = await _clientFactory.CreateClientAsync(connectionContext, cancellationToken);
+ var clientInfo = new FtpClientInformation(client, connectionContext);
+ lock (_activeClientsLock)
+ {
+ _activeClients = _activeClients.Add(clientInfo);
+ }
 
- _logger.LogTrace("FTP client added");
- await client.WaitForExitAsync(connectionContext.ConnectionClosed);
+  _logger.LogTrace("FTP client added");
+  await client.RunAsync(connectionContext.ConnectionClosed);
 
- lock (_activeClientsLock)
+ lock (_activeClientsLock)
+ {
+ _activeClients = _activeClients.Remove(clientInfo);
+ _logger.LogTrace("FTP client removed");
+ }
+ }
+ finally
  {
- _activeClients = _activeClients.Remove(clientInfo);
- _logger.LogTrace("FTP client removed");
+ await connectionContext.DisposeAsync();
  }
  }
 }

samples/FtpServer/Program.cs

@@ -18,8 +18,8 @@
  .AddLogging()
  .AddOptions()
  .AddSingleton<IConnectionListenerFactory, SocketTransportFactory>()
- //.AddEmbeddedClient()
- .AddExternalClient()
+ .AddEmbeddedClient()
+ //.AddExternalClient()
  .AddSingleton<IHostedService, FtpServerService>();
  services
  .Configure<FtpServerOptions>(opt => { opt.ListenEndPoints.Add(new IPEndPoint(IPAddress.IPv6Any, 8021)); });

src/FubarDev.FtpServer.Abstractions/IFtpClient.cs

@@ -6,5 +6,5 @@ namespace FubarDev.FtpServer.Abstractions;
 
 public interface IFtpClient
 {
- Task WaitForExitAsync(CancellationToken cancellationToken = default);
+ ValueTask RunAsync(CancellationToken cancellationToken = default);
 }

src/FubarDev.FtpServer.Client.Common/FtpConnection.cs

@@ -6,12 +6,11 @@
 
 using FubarDev.FtpServer.Abstractions;
 
-using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
 namespace FubarDev.FtpServer.Client.Common;
 
-public class FtpConnection : BackgroundService
+public class FtpConnection
 {
  private readonly IFtpConnectionContextAccessor _connectionContextAccessor;
  private readonly ILogger<FtpConnection> _logger;
@@ -24,7 +23,7 @@ public FtpConnection(
  _logger = logger;
  }
 
- protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+ public async Task RunAsync(CancellationToken stoppingToken = default)
  {
  var connectionContext = _connectionContextAccessor.Context ?? throw new InvalidOperationException();
  var transport = connectionContext.ControlConnection;

src/FubarDev.FtpServer.Client.Embedded/EmbeddedFtpClient.cs

@@ -5,34 +5,57 @@
 using FubarDev.FtpServer.Abstractions;
 using FubarDev.FtpServer.Client.Common;
 
+using Microsoft.AspNetCore.Connections;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
+using Nerdbank.Streams;
+
 namespace FubarDev.FtpServer.Client.Embedded;
 
-internal class EmbeddedFtpClient : IFtpClient, IDisposable
+internal class EmbeddedFtpClient : IFtpClient
 {
- private readonly FtpConnection _connection;
- private readonly CancellationTokenSource _connectionTokenSource;
+ private readonly ConnectionContext _connectionContext;
+ private readonly IFtpConnectionContextAccessor _connectionContextAccessor;
+ private readonly IServiceProvider _serviceProvider;
  private readonly ILogger<EmbeddedFtpClient> _logger;
 
  public EmbeddedFtpClient(
- FtpConnection connection,
- CancellationTokenSource connectionTokenSource,
+ ConnectionContext connectionContext,
+ IFtpConnectionContextAccessor connectionContextAccessor,
+ IServiceProvider serviceProvider,
  ILogger<EmbeddedFtpClient> logger)
  {
- _connection = connection;
- _connectionTokenSource = connectionTokenSource;
+ _connectionContext = connectionContext;
+ _connectionContextAccessor = connectionContextAccessor;
+ _serviceProvider = serviceProvider;
  _logger = logger;
  }
 
- public async Task WaitForExitAsync(CancellationToken cancellationToken = default)
+ public async ValueTask RunAsync(CancellationToken cancellationToken = default)
  {
+ var cts = new CancellationTokenSource();
+ var transport = new DuplexPipe(
+ _connectionContext.Transport.Input,
+ _connectionContext.Transport.Output
+ .OnCompleted((_, _) => cts.Cancel()));
+ _connectionContextAccessor.Context = new FtpConnectionContext(transport);
+ var connection = ActivatorUtilities.CreateInstance<FtpConnection>(_serviceProvider);
+
  using var stoppingTokenSource = CancellationTokenSource.CreateLinkedTokenSource(
  cancellationToken,
- _connectionTokenSource.Token);
+ _connectionContext.ConnectionClosed);
  try
  {
- await Task.Delay(Timeout.Infinite, stoppingTokenSource.Token);
+ using var loggerScope = _logger.BeginScope(
+ new Dictionary<string, object?>()
+ {
+ ["ConnectionId"] = _connectionContext.ConnectionId,
+ ["LocalEndPoint"] = _connectionContext.LocalEndPoint,
+ ["RemoteEndPoint"] = _connectionContext.RemoteEndPoint,
+ });
+ _logger.LogTrace("FTP connection starting");
+ await connection.RunAsync(stoppingTokenSource.Token);
  }
  catch (OperationCanceledException)
  {
@@ -43,12 +66,6 @@ public async Task WaitForExitAsync(CancellationToken cancellationToken = default
  _logger.LogError(exception, "Delay aborted with error {ErrorMessage}", exception.Message);
  }
 
- _logger.LogTrace("Stopping FTP connection");
- await _connection.StopAsync(cancellationToken);
- }
-
- public void Dispose()
- {
- _connectionTokenSource.Dispose();
+ _logger.LogTrace("FTP connection stopped");
  }
 }

src/FubarDev.FtpServer.Client.Embedded/EmbeddedFtpClientFactory.cs

@@ -33,25 +33,9 @@ public async ValueTask<IFtpClient> CreateClientAsync(
  ConnectionContext connectionContext,
  CancellationToken cancellationToken = default)
  {
- var cts = new CancellationTokenSource();
- var transport = new DuplexPipe(
- connectionContext.Transport.Input,
- connectionContext.Transport.Output
- .OnCompleted((_, _) => cts.Cancel()));
- _connectionContextAccessor.Context = new FtpConnectionContext(transport);
- var connection = ActivatorUtilities.CreateInstance<FtpConnection>(_serviceProvider);
- 
- await connection.StartAsync(cancellationToken);
- if (connection.ExecuteTask.IsCompleted)
- {
- _logger.LogWarning("FTP connection stopped too early");
- await connection.ExecuteTask;
- }
-
  var ftpClient = ActivatorUtilities.CreateInstance<EmbeddedFtpClient>(
  _serviceProvider,
- connection,
- cts);
+ connectionContext);
  return ftpClient;
  }
 }

src/FubarDev.FtpServer.Client.External/ExternalFtpClient.cs

@@ -18,7 +18,7 @@ public ExternalFtpClient(
  _executionTask = executionTask;
  }
 
- public async Task WaitForExitAsync(CancellationToken cancellationToken = default)
+ public async ValueTask RunAsync(CancellationToken cancellationToken = default)
  {
  await _executionTask;
  }

src/FubarDev.FtpServer.Client.External/ExternalFtpClientFactory.cs

@@ -9,19 +9,23 @@
 using FubarDev.FtpServer.Abstractions;
 
 using Microsoft.AspNetCore.Connections;
+using Microsoft.Extensions.DependencyInjection;
 
 using Nerdbank.Streams;
 
 namespace FubarDev.FtpServer.Client.External;
 
 public class ExternalFtpClientFactory : IFtpClientFactory
 {
+ private readonly IServiceProvider _serviceProvider;
  private readonly Assembly _clientAssembly;
  private readonly string _clientExecutable;
  private readonly bool _startedWithDotnetTool;
 
- public ExternalFtpClientFactory()
+ public ExternalFtpClientFactory(
+ IServiceProvider serviceProvider)
  {
+ _serviceProvider = serviceProvider;
  var startExecutable = Path.GetFileName(Environment.ProcessPath)
  ?? throw new InvalidOperationException();
  _startedWithDotnetTool = startExecutable.ToLowerInvariant() switch
@@ -42,7 +46,7 @@ public ExternalFtpClientFactory()
  };
  }
 
- public ValueTask<IFtpClient> CreateClientAsync(
+ public async ValueTask<IFtpClient> CreateClientAsync(
  ConnectionContext connectionContext,
  CancellationToken cancellationToken = default)
  {
@@ -62,10 +66,13 @@ public ValueTask<IFtpClient> CreateClientAsync(
  .WithStandardOutputPipe(PipeTarget.ToStream(stream))
  .WithStandardInputPipe(PipeSource.FromStream(stream))
  .WithStandardErrorPipe(PipeTarget.ToStream(Console.OpenStandardError()))
- .ExecuteAsync();
+ .ExecuteAsync(CancellationToken.None);
 
- var ftpClient = new ExternalFtpClient(cliTask);
- return ValueTask.FromResult<IFtpClient>(ftpClient);
+ // var multiplexor = await MultiplexingStream.CreateAsync(stream, cancellationToken);
+ var ftpClient = ActivatorUtilities.CreateInstance<ExternalFtpClient>(
+ _serviceProvider,
+ cliTask);
+ return ftpClient;
  }
 
  private static string? ProbeExecutableFor(Assembly assembly)

src/FubarDev.FtpServer.Client.External/HostedFtpConnection.cs

@@ -0,0 +1,24 @@
+// <copyright file="HostedFtpConnection.cs" company="Fubar Development Junker">
+// Copyright (c) Fubar Development Junker. All rights reserved.
+// </copyright>
+
+using FubarDev.FtpServer.Client.Common;
+
+using Microsoft.Extensions.Hosting;
+
+namespace FubarDev.FtpServer.Client.External;
+
+public class HostedFtpConnection : BackgroundService
+{
+ private readonly FtpConnection _connection;
+
+ public HostedFtpConnection(FtpConnection connection)
+ {
+ _connection = connection;
+ }
+
+ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+ {
+ await _connection.RunAsync(stoppingToken);
+ }
+}

src/FubarDev.FtpServer.Client.External/Program.cs

@@ -6,6 +6,7 @@
 
 using FubarDev.FtpServer.Abstractions;
 using FubarDev.FtpServer.Client.Common;
+using FubarDev.FtpServer.Client.External;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
@@ -31,7 +32,8 @@
  services.Configure<ConsoleLoggerOptions>(
  opt => opt.LogToStandardErrorThreshold = LogLevel.Trace);
  services.AddSingleton<IFtpConnectionContextAccessor, FtpConnectionContextAccessor>();
- services.AddSingleton<IHostedService, FtpConnection>();
+ services.AddSingleton<FtpConnection>();
+ services.AddSingleton<IHostedService, HostedFtpConnection>();
  })
  .Build();