Add extension for RPC calls; replace locks; Refactored storage in Managed Client

2026-10-18 10:26:11 +08:00 · 2017-12-04 10:21:37 +01:00
parent 0ee3c8e135
commit d12d2648b7
31 changed files with 690 additions and 307 deletions
@@ -14,15 +14,17 @@ namespace MQTTnet.Server
 {
    public sealed class MqttClientSession
    {
-        private readonly Stopwatch _lastPacketReceivedTracker = new Stopwatch();
-        private readonly Stopwatch _lastNonKeepAlivePacketReceivedTracker = new Stopwatch();
+        private readonly Stopwatch _lastPacketReceivedTracker = Stopwatch.StartNew();
+        private readonly Stopwatch _lastNonKeepAlivePacketReceivedTracker = Stopwatch.StartNew();

-        private readonly MqttClientSubscriptionsManager _subscriptionsManager;
-        private readonly MqttClientSessionsManager _sessionsManager;
-        private readonly MqttClientPendingMessagesQueue _pendingMessagesQueue;
        private readonly IMqttServerOptions _options;
        private readonly IMqttNetLogger _logger;

+        private readonly MqttClientSessionsManager _sessionsManager;
+        private readonly MqttRetainedMessagesManager _retainedMessagesManager;
+        private readonly MqttClientSubscriptionsManager _subscriptionsManager;
+        private readonly MqttClientPendingMessagesQueue _pendingMessagesQueue;
+
        private IMqttChannelAdapter _adapter;
        private CancellationTokenSource _cancellationTokenSource;
        private MqttApplicationMessage _willMessage;
@@ -30,16 +32,17 @@ namespace MQTTnet.Server
        public MqttClientSession(
            string clientId,
            IMqttServerOptions options,
+            MqttRetainedMessagesManager retainedMessagesManager,
            MqttClientSessionsManager sessionsManager,
            IMqttNetLogger logger)
        {
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+            _retainedMessagesManager = retainedMessagesManager ?? throw new ArgumentNullException(nameof(retainedMessagesManager));
            _sessionsManager = sessionsManager ?? throw new ArgumentNullException(nameof(sessionsManager));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));

            ClientId = clientId;
-
-            _options = options;
-
+            
            _subscriptionsManager = new MqttClientSubscriptionsManager(_options);
            _pendingMessagesQueue = new MqttClientPendingMessagesQueue(_options, this, _logger);
        }
@@ -117,11 +120,11 @@ namespace MQTTnet.Server
            }
        }

-        public void EnqueueApplicationMessage(MqttApplicationMessage applicationMessage)
+        public async Task EnqueueApplicationMessageAsync(MqttApplicationMessage applicationMessage)
        {
            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));

-            var result = _subscriptionsManager.CheckSubscriptions(applicationMessage);
+            var result = await _subscriptionsManager.CheckSubscriptionsAsync(applicationMessage);
            if (!result.IsSubscribed)
            {
                return;
@@ -129,6 +132,7 @@ namespace MQTTnet.Server

            var publishPacket = applicationMessage.ToPublishPacket();
            publishPacket.QualityOfServiceLevel = result.QualityOfServiceLevel;
+
            _pendingMessagesQueue.Enqueue(publishPacket);
        }

@@ -199,7 +203,7 @@ namespace MQTTnet.Server

            if (packet is MqttUnsubscribePacket unsubscribePacket)
            {
-                return adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, _subscriptionsManager.Unsubscribe(unsubscribePacket));
+                return HandleIncomingUnsubscribePacketAsync(adapter, unsubscribePacket, cancellationToken);
            }

            if (packet is MqttDisconnectPacket || packet is MqttConnectPacket)
@@ -213,24 +217,31 @@ namespace MQTTnet.Server

        private async Task HandleIncomingSubscribePacketAsync(IMqttChannelAdapter adapter, MqttSubscribePacket subscribePacket, CancellationToken cancellationToken)
        {
-            var subscribeResult = _subscriptionsManager.Subscribe(subscribePacket, ClientId);
+            var subscribeResult = await _subscriptionsManager.SubscribeAsync(subscribePacket, ClientId);

            await adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, subscribeResult.ResponsePacket).ConfigureAwait(false);
-            await EnqueueSubscribedRetainedMessagesAsync(subscribePacket).ConfigureAwait(false);
-
            if (subscribeResult.CloseConnection)
            {
                await adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, new MqttDisconnectPacket()).ConfigureAwait(false);
                await StopAsync().ConfigureAwait(false);
            }
+
+            await EnqueueSubscribedRetainedMessagesAsync(subscribePacket).ConfigureAwait(false);
+        }
+
+        private async Task HandleIncomingUnsubscribePacketAsync(IMqttChannelAdapter adapter, MqttUnsubscribePacket unsubscribePacket, CancellationToken cancellationToken)
+        {
+            var unsubscribeResult = await _subscriptionsManager.UnsubscribeAsync(unsubscribePacket);
+
+            await adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, unsubscribeResult);
        }

        private async Task EnqueueSubscribedRetainedMessagesAsync(MqttSubscribePacket subscribePacket)
        {
-            var retainedMessages = await _sessionsManager.GetRetainedMessagesAsync(subscribePacket).ConfigureAwait(false);
+            var retainedMessages = await _retainedMessagesManager.GetSubscribedMessagesAsync(subscribePacket);
            foreach (var publishPacket in retainedMessages)
            {
-                EnqueueApplicationMessage(publishPacket);
+                await EnqueueApplicationMessageAsync(publishPacket);
            }
        }

@@ -15,23 +15,21 @@ namespace MQTTnet.Server
    public sealed class MqttClientSessionsManager
    {
        private readonly Dictionary<string, MqttClientSession> _sessions = new Dictionary<string, MqttClientSession>();
-        private readonly SemaphoreSlim _sessionsSemaphore = new SemaphoreSlim(1, 1);
+        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

        private readonly IMqttServerOptions _options;
+        private readonly MqttServer _server;
        private readonly MqttRetainedMessagesManager _retainedMessagesManager;
        private readonly IMqttNetLogger _logger;

-        public MqttClientSessionsManager(IMqttServerOptions options, MqttRetainedMessagesManager retainedMessagesManager, IMqttNetLogger logger)
+        public MqttClientSessionsManager(IMqttServerOptions options, MqttRetainedMessagesManager retainedMessagesManager, MqttServer server, IMqttNetLogger logger)
        {
+            _server = server ?? throw new ArgumentNullException(nameof(server));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
            _options = options ?? throw new ArgumentNullException(nameof(options));
            _retainedMessagesManager = retainedMessagesManager ?? throw new ArgumentNullException(nameof(retainedMessagesManager));
        }

-        public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
-        public event EventHandler<MqttClientDisconnectedEventArgs> ClientDisconnected;
-        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
-
        public async Task RunClientSessionAsync(IMqttChannelAdapter clientAdapter, CancellationToken cancellationToken)
        {
            var clientId = string.Empty;
@@ -66,11 +64,11 @@ namespace MQTTnet.Server
                    IsSessionPresent = clientSession.IsExistingSession
                }).ConfigureAwait(false);

-                ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(new ConnectedMqttClient
+                _server.OnClientConnected(new ConnectedMqttClient
                {
                    ClientId = clientId,
                    ProtocolVersion = clientAdapter.PacketSerializer.ProtocolVersion
-                }));
+                });

                await clientSession.Session.RunAsync(connectPacket.WillMessage, clientAdapter).ConfigureAwait(false);
            }
@@ -89,17 +87,17 @@ namespace MQTTnet.Server
                    // ignored
                }

-                ClientDisconnected?.Invoke(this, new MqttClientDisconnectedEventArgs(new ConnectedMqttClient
+                _server.OnClientDisconnected(new ConnectedMqttClient
                {
                    ClientId = clientId,
                    ProtocolVersion = clientAdapter.PacketSerializer.ProtocolVersion
-                }));
+                });
            }
        }

        public async Task StopAsync()
        {
-            await _sessionsSemaphore.WaitAsync().ConfigureAwait(false);
+            await _semaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                foreach (var session in _sessions)
@@ -111,13 +109,13 @@ namespace MQTTnet.Server
            }
            finally
            {
-                _sessionsSemaphore.Release();
+                _semaphore.Release();
            }
        }

        public async Task<IList<ConnectedMqttClient>> GetConnectedClientsAsync()
        {
-            await _sessionsSemaphore.WaitAsync().ConfigureAwait(false);
+            await _semaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                return _sessions.Where(s => s.Value.IsConnected).Select(s => new ConnectedMqttClient
@@ -130,7 +128,7 @@ namespace MQTTnet.Server
            }
            finally
            {
-                _sessionsSemaphore.Release();
+                _semaphore.Release();
            }
        }

@@ -138,17 +136,7 @@ namespace MQTTnet.Server
        {
            try
            {
-                if (_options.ApplicationMessageInterceptor != null)
-                {
-                    var interceptorContext = new MqttApplicationMessageInterceptorContext
-                    {
-                        ApplicationMessage = applicationMessage
-                    };
-
-                    _options.ApplicationMessageInterceptor(interceptorContext);
-                    applicationMessage = interceptorContext.ApplicationMessage;
-                }
-
+                applicationMessage = InterceptApplicationMessage(applicationMessage);
                if (applicationMessage == null)
                {
                    return;
@@ -159,26 +147,41 @@ namespace MQTTnet.Server
                    await _retainedMessagesManager.HandleMessageAsync(senderClientSession?.ClientId, applicationMessage).ConfigureAwait(false);
                }

-                var eventArgs = new MqttApplicationMessageReceivedEventArgs(senderClientSession?.ClientId, applicationMessage);
-                ApplicationMessageReceived?.Invoke(this, eventArgs);
+                _server.OnApplicationMessageReceived(senderClientSession?.ClientId, applicationMessage);
            }
            catch (Exception exception)
            {
                _logger.Error<MqttClientSessionsManager>(exception, "Error while processing application message");
            }

-            lock (_sessions)
+            await _semaphore.WaitAsync().ConfigureAwait(false);
+            try
            {
                foreach (var clientSession in _sessions.Values)
                {
-                    clientSession.EnqueueApplicationMessage(applicationMessage);
+                    await clientSession.EnqueueApplicationMessageAsync(applicationMessage);
                }
            }
+            finally
+            {
+                _semaphore.Release();
+            }
        }

-        public Task<List<MqttApplicationMessage>> GetRetainedMessagesAsync(MqttSubscribePacket subscribePacket)
+        private MqttApplicationMessage InterceptApplicationMessage(MqttApplicationMessage applicationMessage)
        {
-            return _retainedMessagesManager.GetSubscribedMessagesAsync(subscribePacket);
+            if (_options.ApplicationMessageInterceptor == null)
+            {
+                return applicationMessage;
+            }
+
+            var interceptorContext = new MqttApplicationMessageInterceptorContext
+            {
+                ApplicationMessage = applicationMessage
+            };
+
+            _options.ApplicationMessageInterceptor(interceptorContext);
+            return interceptorContext.ApplicationMessage;
        }

        private MqttConnectReturnCode ValidateConnection(MqttConnectPacket connectPacket)
@@ -200,7 +203,7 @@ namespace MQTTnet.Server

        private async Task<GetOrCreateClientSessionResult> GetOrCreateClientSessionAsync(MqttConnectPacket connectPacket)
        {
-            await _sessionsSemaphore.WaitAsync().ConfigureAwait(false);
+            await _semaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                var isSessionPresent = _sessions.TryGetValue(connectPacket.ClientId, out var clientSession);
@@ -225,7 +228,7 @@ namespace MQTTnet.Server
                {
                    isExistingSession = false;

-                    clientSession = new MqttClientSession(connectPacket.ClientId, _options, this, _logger);
+                    clientSession = new MqttClientSession(connectPacket.ClientId, _options, _retainedMessagesManager, this, _logger);
                    _sessions[connectPacket.ClientId] = clientSession;

                    _logger.Trace<MqttClientSessionsManager>("Created a new session for client '{0}'.", connectPacket.ClientId);
@@ -235,7 +238,7 @@ namespace MQTTnet.Server
            }
            finally
            {
-                _sessionsSemaphore.Release();
+                _semaphore.Release();
            }
        }
    }
@@ -1,5 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;

@@ -7,6 +10,7 @@ namespace MQTTnet.Server
 {
    public sealed class MqttClientSubscriptionsManager
    {
+        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
        private readonly Dictionary<string, MqttQualityOfServiceLevel> _subscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
        private readonly IMqttServerOptions _options;

@@ -15,24 +19,34 @@ namespace MQTTnet.Server
            _options = options ?? throw new ArgumentNullException(nameof(options));
        }

-        public MqttClientSubscribeResult Subscribe(MqttSubscribePacket subscribePacket, string clientId)
+        public async Task<MqttClientSubscribeResult> SubscribeAsync(MqttSubscribePacket subscribePacket, string clientId)
        {
            if (subscribePacket == null) throw new ArgumentNullException(nameof(subscribePacket));

-            var responsePacket = subscribePacket.CreateResponse<MqttSubAckPacket>();
-            var closeConnection = false;
+            var result = new MqttClientSubscribeResult
+            {
+                ResponsePacket = subscribePacket.CreateResponse<MqttSubAckPacket>(),
+                CloseConnection = false
+            };

-            lock (_subscriptions)
+            await _semaphore.WaitAsync().ConfigureAwait(false);
+            try
            {
                foreach (var topicFilter in subscribePacket.TopicFilters)
                {
-                    var interceptorContext = new MqttSubscriptionInterceptorContext(clientId, topicFilter);
-                    _options.SubscriptionInterceptor?.Invoke(interceptorContext);
-                    responsePacket.SubscribeReturnCodes.Add(interceptorContext.AcceptSubscription ? MqttSubscribeReturnCode.SuccessMaximumQoS1 : MqttSubscribeReturnCode.Failure);
-                    
+                    var interceptorContext = InterceptSubscribe(clientId, topicFilter);
+                    if (!interceptorContext.AcceptSubscription)
+                    {
+                        result.ResponsePacket.SubscribeReturnCodes.Add(MqttSubscribeReturnCode.Failure);
+                    }
+                    else
+                    {
+                        result.ResponsePacket.SubscribeReturnCodes.Add(ConvertToMaximumQoS(topicFilter.QualityOfServiceLevel));
+                    }
+
                    if (interceptorContext.CloseConnection)
                    {
-                        closeConnection = true;
+                        result.CloseConnection = true;
                    }

                    if (interceptorContext.AcceptSubscription)
@@ -41,35 +55,42 @@ namespace MQTTnet.Server
                    }
                }
            }
-
-            return new MqttClientSubscribeResult
+            finally
            {
-                ResponsePacket = responsePacket,
-                CloseConnection = closeConnection
-            };
+                _semaphore.Release();
+            }
+
+            return result;
        }

-        public MqttUnsubAckPacket Unsubscribe(MqttUnsubscribePacket unsubscribePacket)
+        public async Task<MqttUnsubAckPacket> UnsubscribeAsync(MqttUnsubscribePacket unsubscribePacket)
        {
            if (unsubscribePacket == null) throw new ArgumentNullException(nameof(unsubscribePacket));

-            lock (_subscriptions)
+            await _semaphore.WaitAsync().ConfigureAwait(false);
+            try
            {
                foreach (var topicFilter in unsubscribePacket.TopicFilters)
                {
                    _subscriptions.Remove(topicFilter);
                }
            }
+            finally
+            {
+                _semaphore.Release();
+            }

            return unsubscribePacket.CreateResponse<MqttUnsubAckPacket>();
        }

-        public CheckSubscriptionsResult CheckSubscriptions(MqttApplicationMessage applicationMessage)
+        public async Task<CheckSubscriptionsResult> CheckSubscriptionsAsync(MqttApplicationMessage applicationMessage)
        {
            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));

-            lock (_subscriptions)
+            await _semaphore.WaitAsync().ConfigureAwait(false);
+            try
            {
+                var qosLevels = new HashSet<MqttQualityOfServiceLevel>();
                foreach (var subscription in _subscriptions)
                {
                    if (!MqttTopicFilterComparer.IsMatch(applicationMessage.Topic, subscription.Key))
@@ -77,24 +98,64 @@ namespace MQTTnet.Server
                        continue;
                    }

-                    var effectiveQos = subscription.Value;
-                    if (applicationMessage.QualityOfServiceLevel < effectiveQos)
-                    {
-                        effectiveQos = applicationMessage.QualityOfServiceLevel;
-                    }
+                    qosLevels.Add(subscription.Value);
+                }

+                if (qosLevels.Count == 0)
+                {
                    return new CheckSubscriptionsResult
                    {
-                        IsSubscribed = true,
-                        QualityOfServiceLevel = effectiveQos
+                        IsSubscribed = false
                    };
                }
+
+                return CreateSubscriptionResult(applicationMessage, qosLevels);
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+
+        private MqttSubscriptionInterceptorContext InterceptSubscribe(string clientId, TopicFilter topicFilter)
+        {
+            var interceptorContext = new MqttSubscriptionInterceptorContext(clientId, topicFilter);
+            _options.SubscriptionInterceptor?.Invoke(interceptorContext);
+            return interceptorContext;
+        }
+
+        private static CheckSubscriptionsResult CreateSubscriptionResult(MqttApplicationMessage applicationMessage, HashSet<MqttQualityOfServiceLevel> subscribedQoSLevels)
+        {
+            MqttQualityOfServiceLevel effectiveQoS;
+            if (subscribedQoSLevels.Contains(applicationMessage.QualityOfServiceLevel))
+            {
+                effectiveQoS = applicationMessage.QualityOfServiceLevel;
+            }
+            else if (subscribedQoSLevels.Count == 1)
+            {
+                effectiveQoS = subscribedQoSLevels.First();
+            }
+            else
+            {
+                effectiveQoS = subscribedQoSLevels.Max();
            }

            return new CheckSubscriptionsResult
            {
-                IsSubscribed = false
+                IsSubscribed = true,
+                QualityOfServiceLevel = effectiveQoS
            };
        }
+
+        private static MqttSubscribeReturnCode ConvertToMaximumQoS(MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            switch (qualityOfServiceLevel)
+            {
+                case MqttQualityOfServiceLevel.AtMostOnce: return MqttSubscribeReturnCode.SuccessMaximumQoS0;
+                case MqttQualityOfServiceLevel.AtLeastOnce: return MqttSubscribeReturnCode.SuccessMaximumQoS1;
+                case MqttQualityOfServiceLevel.ExactlyOnce: return MqttSubscribeReturnCode.SuccessMaximumQoS2;
+                default: return MqttSubscribeReturnCode.Failure;
+            }
+        }
    }
 }
@@ -11,7 +11,7 @@ namespace MQTTnet.Server
    public sealed class MqttRetainedMessagesManager
    {
        private readonly Dictionary<string, MqttApplicationMessage> _retainedMessages = new Dictionary<string, MqttApplicationMessage>();
-        private readonly SemaphoreSlim _gate = new SemaphoreSlim(1, 1);
+        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
        private readonly IMqttNetLogger _logger;
        private readonly IMqttServerOptions _options;

@@ -28,7 +28,7 @@ namespace MQTTnet.Server
                return;
            }

-            await _gate.WaitAsync();
+            await _semaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                var retainedMessages = await _options.Storage.LoadRetainedMessagesAsync();
@@ -45,7 +45,7 @@ namespace MQTTnet.Server
            }
            finally
            {
-                _gate.Release();
+                _semaphore.Release();
            }
        }

@@ -53,7 +53,7 @@ namespace MQTTnet.Server
        {
            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));

-            await _gate.WaitAsync().ConfigureAwait(false);
+            await _semaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                await HandleMessageInternalAsync(clientId, applicationMessage);
@@ -64,7 +64,7 @@ namespace MQTTnet.Server
            }
            finally
            {
-                _gate.Release();
+                _semaphore.Release();
            }
        }

@@ -72,7 +72,7 @@ namespace MQTTnet.Server
        {
            var retainedMessages = new List<MqttApplicationMessage>();

-            await _gate.WaitAsync().ConfigureAwait(false);
+            await _semaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                foreach (var retainedMessage in _retainedMessages.Values)
@@ -96,7 +96,7 @@ namespace MQTTnet.Server
            }
            finally
            {
-                _gate.Release();
+                _semaphore.Release();
            }

            return retainedMessages;
@@ -60,11 +60,7 @@ namespace MQTTnet.Server

            _cancellationTokenSource = new CancellationTokenSource();
            _retainedMessagesManager = new MqttRetainedMessagesManager(_options, _logger);
-
-            _clientSessionsManager = new MqttClientSessionsManager(_options, _retainedMessagesManager, _logger);
-            _clientSessionsManager.ApplicationMessageReceived += OnApplicationMessageReceived;
-            _clientSessionsManager.ClientConnected += OnClientConnected;
-            _clientSessionsManager.ClientDisconnected += OnClientDisconnected;
+            _clientSessionsManager = new MqttClientSessionsManager(_options, _retainedMessagesManager, this, _logger);

            await _retainedMessagesManager.LoadMessagesAsync();

@@ -104,40 +100,39 @@ namespace MQTTnet.Server
            finally
            {
                _cancellationTokenSource = null;
-
                _retainedMessagesManager = null;
-
-                if (_clientSessionsManager != null)
-                {
-                    _clientSessionsManager.ApplicationMessageReceived -= OnApplicationMessageReceived;
-                    _clientSessionsManager.ClientConnected -= OnClientConnected;
-                    _clientSessionsManager.ClientDisconnected -= OnClientDisconnected;
-                }
-
                _clientSessionsManager = null;
            }
        }

+        internal void OnClientConnected(ConnectedMqttClient client)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+
+            _logger.Info<MqttServer>("Client '{0}': Connected.", client.ClientId);
+            ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(client));
+        }
+
+        internal void OnClientDisconnected(ConnectedMqttClient client)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+
+            _logger.Info<MqttServer>("Client '{0}': Disconnected.", client.ClientId);
+            ClientDisconnected?.Invoke(this, new MqttClientDisconnectedEventArgs(client));
+        }
+
+        internal void OnApplicationMessageReceived(string clientId, MqttApplicationMessage applicationMessage)
+        {
+            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));
+
+            ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(clientId, applicationMessage));
+        }
+
        private void OnClientAccepted(object sender, MqttServerAdapterClientAcceptedEventArgs eventArgs)
        {
-            eventArgs.SessionTask = Task.Run(async () => await _clientSessionsManager.RunClientSessionAsync(eventArgs.Client, _cancellationTokenSource.Token), _cancellationTokenSource.Token);
-        }
-
-        private void OnClientConnected(object sender, MqttClientConnectedEventArgs eventArgs)
-        {
-            _logger.Info<MqttServer>("Client '{0}': Connected.", eventArgs.Client.ClientId);
-            ClientConnected?.Invoke(this, eventArgs);
-        }
-
-        private void OnClientDisconnected(object sender, MqttClientDisconnectedEventArgs eventArgs)
-        {
-            _logger.Info<MqttServer>("Client '{0}': Disconnected.", eventArgs.Client.ClientId);
-            ClientDisconnected?.Invoke(this, eventArgs);
-        }
-
-        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs e)
-        {
-            ApplicationMessageReceived?.Invoke(this, e);
+            eventArgs.SessionTask = Task.Run(
+                async () => await _clientSessionsManager.RunClientSessionAsync(eventArgs.Client, _cancellationTokenSource.Token).ConfigureAwait(false),
+                _cancellationTokenSource.Token);
        }
    }
 }
@@ -1,17 +1,19 @@
-namespace MQTTnet.Server
+using System;
+
+namespace MQTTnet.Server
 {
    public class MqttSubscriptionInterceptorContext
    {
        public MqttSubscriptionInterceptorContext(string clientId, TopicFilter topicFilter)
        {
            ClientId = clientId;
-            TopicFilter = topicFilter;
+            TopicFilter = topicFilter ?? throw new ArgumentNullException(nameof(topicFilter));
        }

        public string ClientId { get; }

        public TopicFilter TopicFilter { get; }
-
+        
        public bool AcceptSubscription { get; set; } = true;

        public bool CloseConnection { get; set; }