async Task HandlePublishReleaseAsync(string clientId, PublishRelease publishRelease, IMqttChannel <IPacket> channel) { RemovePendingAcknowledgement(clientId, publishRelease.PacketId, MqttPacketType.PublishReceived); await SendAckAsync(clientId, new PublishComplete (publishRelease.PacketId), channel) .ConfigureAwait(continueOnCapturedContext: false); }
public async Task when_writing_publish_release_packet_then_succeeds(string jsonPath, string packetPath) { jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath); packetPath = Path.Combine(Environment.CurrentDirectory, packetPath); byte[] expectedPacket = Packet.ReadAllBytes(packetPath); FlowPacketFormatter <PublishRelease> formatter = new FlowPacketFormatter <PublishRelease>(MqttPacketType.PublishRelease, id => new PublishRelease(id)); PublishRelease publishRelease = Packet.ReadPacket <PublishRelease>(jsonPath); byte[] result = await formatter.FormatAsync(publishRelease); expectedPacket.Should().BeEquivalentTo(result); }
public override async Task ExecuteAsync(string clientId, IPacket input, IMqttChannel <IPacket> channel) { if (input.Type == MqttPacketType.Publish) { Publish publish = input as Publish; await HandlePublishAsync(clientId, publish, channel); } else if (input.Type == MqttPacketType.PublishRelease) { PublishRelease publishRelease = input as PublishRelease; await HandlePublishReleaseAsync(clientId, publishRelease, channel); } }
async Task SendPendingAcknowledgementsAsync(ClientSession session, IMqttChannel <IPacket> channel) { foreach (PendingAcknowledgement pendingAcknowledgement in session.GetPendingAcknowledgements()) { IFlowPacket ack = default; if (pendingAcknowledgement.Type == MqttPacketType.PublishReceived) { ack = new PublishReceived(pendingAcknowledgement.PacketId); } else if (pendingAcknowledgement.Type == MqttPacketType.PublishRelease) { ack = new PublishRelease(pendingAcknowledgement.PacketId); } await _senderFlow.SendAckAsync(session.Id, ack, channel); } }
async Task SendPendingAcknowledgementsAsync(ClientSession session, IMqttChannel <IPacket> channel) { foreach (var pendingAcknowledgement in session.GetPendingAcknowledgements()) { var ack = default(IFlowPacket); if (pendingAcknowledgement.Type == MqttPacketType.PublishReceived) { ack = new PublishReceived(pendingAcknowledgement.PacketId); } else if (pendingAcknowledgement.Type == MqttPacketType.PublishRelease) { ack = new PublishRelease(pendingAcknowledgement.PacketId); } await senderFlow.SendAckAsync(session.ClientId, ack, channel, PendingMessageStatus.PendingToAcknowledge) .ConfigureAwait(continueOnCapturedContext: false); } }
public async Task when_sending_publish_release_then_publish_complete_is_sent() { var clientId = Guid.NewGuid().ToString(); var configuration = Mock.Of <MqttConfiguration> (); var topicEvaluator = new Mock <IMqttTopicEvaluator> (); var connectionProvider = new Mock <IConnectionProvider> (); var publishSenderFlow = new Mock <IPublishSenderFlow> (); var retainedRepository = Mock.Of <IRepository <RetainedMessage> > (); var sessionRepository = new Mock <IRepository <ClientSession> > (); var willRepository = new Mock <IRepository <ConnectionWill> >(); sessionRepository.Setup(r => r.Get(It.IsAny <Expression <Func <ClientSession, bool> > > ())) .Returns(new ClientSession { ClientId = clientId, PendingMessages = new List <PendingMessage> { new PendingMessage() } }); var packetIdProvider = Mock.Of <IPacketIdProvider> (); var undeliveredMessagesListener = new Subject <MqttUndeliveredMessage> (); var flow = new ServerPublishReceiverFlow(topicEvaluator.Object, connectionProvider.Object, publishSenderFlow.Object, retainedRepository, sessionRepository.Object, willRepository.Object, packetIdProvider, undeliveredMessagesListener, configuration); var packetId = (ushort)new Random().Next(0, ushort.MaxValue); var publishRelease = new PublishRelease(packetId); var channel = new Mock <IMqttChannel <IPacket> > (); channel.Setup(c => c.IsConnected).Returns(true); await flow.ExecuteAsync(clientId, publishRelease, channel.Object) .ConfigureAwait(continueOnCapturedContext: false); channel.Verify(c => c.SendAsync(It.Is <IPacket> (p => p is PublishComplete && (p as PublishComplete).PacketId == packetId))); }
async Task HandlePublishReleaseAsync(string clientId, PublishRelease publishRelease, IMqttChannel <IPacket> channel) { RemovePendingAcknowledgement(clientId, publishRelease.PacketId, MqttPacketType.PublishReceived); await SendAckAsync(clientId, new PublishComplete( publishRelease.PacketId ), channel); }