first iteration

2026-10-20 19:58:57 +08:00 · 2018-06-16 17:20:00 +02:00
parent caea7910b4
commit c758ae89f4
7 changed files with 313 additions and 4 deletions
@@ -0,0 +1,136 @@
+using Microsoft.AspNetCore.Connections;
+using MQTTnet.Adapter;
+using MQTTnet.Packets;
+using MQTTnet.Serializer;
+using System;
+using System.Collections.Generic;
+using System.IO.Pipelines;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.AspNetCore
+{
+    public class MqttConnectionContext : IMqttChannelAdapter
+    {
+        public IMqttPacketSerializer PacketSerializer { get; }
+        public ConnectionContext Connection { get; }
+
+        public string Endpoint => Connection.ConnectionId;
+
+        public MqttConnectionContext(
+            IMqttPacketSerializer packetSerializer,
+            ConnectionContext connection)
+        {
+            PacketSerializer = packetSerializer;
+            Connection = connection;
+        }
+
+        public Task ConnectAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task DisconnectAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            Connection.Transport.Input.Complete();
+            Connection.Transport.Output.Complete();
+            return Task.CompletedTask;
+        }
+
+        public void Dispose()
+        {
+        }
+
+        public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            var input = Connection.Transport.Input;
+
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                ReadResult readResult;
+                
+                var readTask = input.ReadAsync(cancellationToken);
+                if (readTask.IsCompleted)
+                {
+                    readResult = readTask.Result;
+                }
+                else
+                {
+                    readResult = await readTask;
+                }
+
+                var buffer = readResult.Buffer;
+
+                var consumed = buffer.Start;
+                var observed = buffer.Start;
+
+                try
+                {
+                    if (!buffer.IsEmpty)
+                    {
+                        if (PacketSerializer.TryDeserialize(buffer, out var packet, out consumed, out observed))
+                        {
+                            return packet;
+                        }
+                    }
+                    else if (readResult.IsCompleted)
+                    {
+                        break;
+                    }
+                }
+                finally
+                {
+                    // The buffer was sliced up to where it was consumed, so we can just advance to the start.
+                    // We mark examined as buffer.End so that if we didn't receive a full frame, we'll wait for more data
+                    // before yielding the read again.
+                    input.AdvanceTo(consumed, observed);
+                }
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+            return null;
+        }       
+
+        public async Task SendPacketsAsync(TimeSpan timeout, IEnumerable<MqttBasePacket> packets, CancellationToken cancellationToken)
+        {
+            foreach (var packet in packets)
+            {
+                await WriteAsync(packet);
+            }
+        }
+
+        public async Task WriteAsync(MqttBasePacket packet)
+        {
+            var buffer = PacketSerializer.Serialize(packet);
+            await Connection.Transport.Output.WriteAsync(buffer.AsMemory());
+        }
+
+        private int messageId;
+        public Task PublishAsync(MqttPublishPacket packet)
+        {
+            if (!packet.PacketIdentifier.HasValue && packet.QualityOfServiceLevel > MQTTnet.Protocol.MqttQualityOfServiceLevel.AtMostOnce)
+            {
+                packet.PacketIdentifier = (ushort)Interlocked.Increment(ref messageId);
+            }
+            return WriteAsync(packet);
+        }
+
+        public Task SubscribeAsync(MqttSubscribePacket packet)
+        {
+            if (!packet.PacketIdentifier.HasValue)
+            {
+                packet.PacketIdentifier = (ushort)Interlocked.Increment(ref messageId);
+            }
+            return WriteAsync(packet);
+        }
+
+        public Task ConnectAsync(MqttConnectPacket packet)
+        {
+            if (string.IsNullOrEmpty(packet.ClientId))
+            {
+                packet.ClientId = Guid.NewGuid().ToString();
+            }
+            return WriteAsync(packet);
+        }
+    }
+}