public override async Task OnConnectedAsync(ConnectionContext connection)
{
var serializer = new MqttPacketSerializer();
using (var adapter = new MqttConnectionContext(serializer, connection))
{
var args = new MqttServerAdapterClientAcceptedEventArgs(adapter);
ClientAccepted?.Invoke(this, args);
await args.SessionTask;
}
}
public Task AcceptWebSocketAsync(WebSocket webSocket)
{
if (webSocket == null)
{
throw new ArgumentNullException(nameof(webSocket));
}
var channel = new MqttWebSocketServerChannel(webSocket);
var clientAdapter = _mqttCommunicationAdapterFactory.CreateServerCommunicationAdapter(channel);
var eventArgs = new MqttServerAdapterClientAcceptedEventArgs(clientAdapter);
ClientAccepted?.Invoke(this, eventArgs);
return(eventArgs.SessionTask);
}
public Task AcceptWebSocketAsync(WebSocket webSocket)
{
if (webSocket == null)
{
throw new ArgumentNullException(nameof(webSocket));
}
var channel = new MqttWebSocketServerChannel(webSocket);
var clientAdapter = new MqttChannelAdapter(channel, new MqttPacketSerializer(), new MqttNetLogger());
var eventArgs = new MqttServerAdapterClientAcceptedEventArgs(clientAdapter);
ClientAccepted?.Invoke(this, eventArgs);
return(eventArgs.SessionTask);
}
public async Task RunWebSocketConnectionAsync(WebSocket webSocket, string endpoint)
{
if (webSocket == null)
{
throw new ArgumentNullException(nameof(webSocket));
}
var clientAdapter = new MqttChannelAdapter(new MqttWebSocketChannel(webSocket, endpoint), new MqttPacketSerializer(), new MqttNetLogger().CreateChildLogger(nameof(MqttWebSocketServerAdapter)));
var eventArgs = new MqttServerAdapterClientAcceptedEventArgs(clientAdapter);
ClientAccepted?.Invoke(this, eventArgs);
if (eventArgs.SessionTask != null)
{
await eventArgs.SessionTask.ConfigureAwait(false);
}
}
public override async Task OnConnectedAsync(ConnectionContext connection)
{
// required for websocket transport to work
var transferFormatFeature = connection.Features.Get <ITransferFormatFeature>();
if (transferFormatFeature != null)
{
transferFormatFeature.ActiveFormat = TransferFormat.Binary;
}
var serializer = new MqttPacketSerializer();
using (var adapter = new MqttConnectionContext(serializer, connection))
{
var args = new MqttServerAdapterClientAcceptedEventArgs(adapter);
ClientAccepted?.Invoke(this, args);
await args.SessionTask;
}
}
private void OnClientAccepted(object sender, MqttServerAdapterClientAcceptedEventArgs eventArgs)
{
eventArgs.SessionTask = _clientSessionsManager.StartSession(eventArgs.Client);
}
private void OnClientAccepted(object sender, MqttServerAdapterClientAcceptedEventArgs e)
{
ClientAccepted?.Invoke(this, e);
}
private void OnClientAccepted(object sender, MqttServerAdapterClientAcceptedEventArgs eventArgs)
{
eventArgs.SessionTask = Task.Run(
() => _clientSessionsManager.RunSessionAsync(eventArgs.Client, _cancellationTokenSource.Token),
_cancellationTokenSource.Token);
}
private void OnClientAccepted(object sender, MqttServerAdapterClientAcceptedEventArgs eventArgs)
{
eventArgs.SessionTask = Task.Run(
async() => await _clientSessionsManager.RunClientSessionAsync(eventArgs.Client, _cancellationTokenSource.Token).ConfigureAwait(false),
_cancellationTokenSource.Token);
}
private async Task TryHandleClientConnectionAsync(Socket clientSocket)
{
var socketIndex = Interlocked.Increment(ref latestSocketIndex);
string clientPrefix = null;
string serverEndPont = null;
SslStream sslStream = null;
var stopwatch = new Stopwatch();
try
{
stopwatch.Start();
clientPrefix = $"Socket[{socketIndex}, {clientSocket.RemoteEndPoint}]";
serverEndPont = string.Format("{0}, {1}, {2}",
_socket.LocalEndPoint,
_addressFamily == AddressFamily.InterNetwork ? "ipv4" : "ipv6",
_tlsCertificate == null ? "tcp" : "tls");
_logger.Verbose($"{clientPrefix} > Accepted by TCP listener '{serverEndPont}'. Time:{stopwatch.Elapsed.TotalMilliseconds}ms");
clientSocket.NoDelay = true;
if (_tlsCertificate != null)
{//如果不设置超时，AuthenticateAsServerAsync 可能会一直阻塞下去
clientSocket.ReceiveTimeout = (int)_communicationTimeout.TotalMilliseconds;
clientSocket.SendTimeout = (int)_communicationTimeout.TotalMilliseconds;
var stream = new NetworkStream(clientSocket, true);
sslStream = new SslStream(stream, false);
var cancellationTokenDisposeSslStream = new CancellationTokenSource();
var taskDisposeSslStream = Task.Delay(_communicationTimeout, cancellationTokenDisposeSslStream.Token)
.ContinueWith((task) =>
{
if (task.IsCanceled)
{
return;
}
if (cancellationTokenDisposeSslStream.IsCancellationRequested)
{
return;
}
//超时，则清理掉
Cleanup(clientSocket, sslStream);
});
await sslStream.AuthenticateAsServerAsync(_tlsCertificate, false, _tlsOptions.SslProtocol, false).ConfigureAwait(false);
cancellationTokenDisposeSslStream.Cancel();
_logger.Verbose($"{clientPrefix} > SslStream created. Time:{stopwatch.Elapsed.TotalMilliseconds}ms");
}
_logger.Verbose($"{clientPrefix} > Processed. Time:{stopwatch.Elapsed.TotalMilliseconds}ms");
if (ClientAccepted != null)
{
using (var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(clientSocket, sslStream), new MqttPacketSerializer(), _logger))
{
var args = new MqttServerAdapterClientAcceptedEventArgs(clientAdapter);
ClientAccepted.Invoke(this, args);
await args.SessionTask.ConfigureAwait(false);
}
}
}
catch (ObjectDisposedException exception)
{
// It can happen that the listener socket is accessed after the cancellation token is already set and the listener socket is disposed.
_logger.Error(exception, $"{clientPrefix} > Error while handling client connection. Listener:'{serverEndPont}' Time:{stopwatch.Elapsed.TotalMilliseconds}ms Disposed");
}
catch (Exception exception)
{
Cleanup(clientSocket, sslStream);
if (exception is SocketException s && s.SocketErrorCode == SocketError.OperationAborted)
{
_logger.Error(exception, $"{clientPrefix} > Error while handling client connection. Listener:'{serverEndPont}' Time:{stopwatch.Elapsed.TotalMilliseconds}ms OperationAborted");
return;
}
if (exception is System.IO.IOException ioException)
{
_logger.Error(exception, $"{clientPrefix} > Error while handling client connection. Listener:'{serverEndPont}' Time:{stopwatch.Elapsed.TotalMilliseconds}ms IOException");
return;
}
_logger.Error(exception, $"{clientPrefix} > Error while handling client connection. Listener:'{serverEndPont}' Time:{stopwatch.Elapsed.TotalMilliseconds}ms Unknown");
}
finally
{
try
{
Cleanup(clientSocket, sslStream);
_logger.Verbose($"{clientPrefix} > Disconnected at TCP listener '{serverEndPont}'. Time:{stopwatch.Elapsed.TotalMilliseconds}ms");
}
catch (Exception disposeException)
{
_logger.Error(disposeException, $"{clientPrefix} > Error while cleaning up client connection. Listener:'{serverEndPont}' Time:{stopwatch.Elapsed.TotalMilliseconds}ms");
}
stopwatch.Stop();
}
}
