public async Task Unsubscribe(IChannelHandlerContext context, UnsubscribePacket packet)
{
string [] topics = packet.TopicFilters.ToArray();
await _channelService.UnSubscribe(await _channelService.GetDeviceId(context.Channel), topics);
await UnsubAck(context, UnsubAckPacket.InResponseTo(packet));
}
static async Task RunMqttServerScenarioAsync(IChannel channel, ReadListeningHandler readListener)
{
var connectPacket = await readListener.ReceiveAsync(DefaultTimeout) as ConnectPacket;
Assert.IsNotNull(connectPacket, "Must be a Connect pkt");
// todo verify
await channel.WriteAndFlushAsync(new ConnAckPacket
{
ReturnCode = ConnectReturnCode.Accepted,
SessionPresent = true
});
var subscribePacket = await readListener.ReceiveAsync(DefaultTimeout) as SubscribePacket;
Assert.IsNotNull(subscribePacket);
// todo verify
await channel.WriteAndFlushAsync(SubAckPacket.InResponseTo(subscribePacket, QualityOfService.ExactlyOnce));
var unsubscribePacket = await readListener.ReceiveAsync(DefaultTimeout) as UnsubscribePacket;
Assert.IsNotNull(unsubscribePacket);
// todo verify
await channel.WriteAndFlushAsync(UnsubAckPacket.InResponseTo(unsubscribePacket));
var publishQos0Packet = await readListener.ReceiveAsync(DefaultTimeout) as PublishPacket;
Assert.IsNotNull(publishQos0Packet);
// todo verify
var publishQos1Packet = await readListener.ReceiveAsync(DefaultTimeout) as PublishPacket;
Assert.IsNotNull(publishQos1Packet);
// todo verify
int publishQos1PacketId = GetRandomPacketId();
await channel.WriteAndFlushManyAsync(
PubAckPacket.InResponseTo(publishQos1Packet),
new PublishPacket(QualityOfService.AtLeastOnce, false, false)
{
PacketId = publishQos1PacketId,
TopicName = PublishS2CQos1Topic,
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(PublishS2CQos1Payload))
});
var pubAckPacket = await readListener.ReceiveAsync(DefaultTimeout) as PubAckPacket;
Assert.AreEqual(publishQos1PacketId, pubAckPacket.PacketId);
var disconnectPacket = await readListener.ReceiveAsync(DefaultTimeout) as DisconnectPacket;
Assert.IsNotNull(disconnectPacket);
}
void ProcessUnsubAck(UnsubAckPacket packet)
{
Contract.Assert(packet != null);
TaskCompletionSource task;
if (this.unsubscribeCompletions.TryRemove(packet.PacketId, out task))
{
task.TryComplete();
}
}
IEnumerable <TestScenarioStep> GetMqttServerScenario(Func <object> currentMessageFunc)
{
yield return(TestScenarioStep.MoreFeedbackExpected());
var connectPacket = Assert.IsType <ConnectPacket>(currentMessageFunc());
// todo verify
yield return(TestScenarioStep.Message(new ConnAckPacket
{
ReturnCode = ConnectReturnCode.Accepted,
SessionPresent = true
}));
var subscribePacket = Assert.IsType <SubscribePacket>(currentMessageFunc());
// todo verify
yield return(TestScenarioStep.Message(SubAckPacket.InResponseTo(subscribePacket, QualityOfService.ExactlyOnce)));
var unsubscribePacket = Assert.IsType <UnsubscribePacket>(currentMessageFunc());
// todo verify
yield return(TestScenarioStep.Message(UnsubAckPacket.InResponseTo(unsubscribePacket)));
var publishQos0Packet = Assert.IsType <PublishPacket>(currentMessageFunc());
// todo verify
yield return(TestScenarioStep.MoreFeedbackExpected());
var publishQos1Packet = Assert.IsType <PublishPacket>(currentMessageFunc());
// todo verify
int publishQos1PacketId = GetRandomPacketId();
yield return(TestScenarioStep.Messages(PubAckPacket.InResponseTo(publishQos1Packet),
new PublishPacket(QualityOfService.AtLeastOnce, false, false)
{
PacketId = publishQos1PacketId,
TopicName = PublishS2CQos1Topic,
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(PublishS2CQos1Payload))
}));
var pubAckPacket = Assert.IsType <PubAckPacket>(currentMessageFunc());
Assert.Equal(publishQos1PacketId, pubAckPacket.PacketId);
yield return(TestScenarioStep.MoreFeedbackExpected());
var disconnectPacket = Assert.IsType <DisconnectPacket>(currentMessageFunc());
}
public static UnsubAckPacket RemoveSubscriptions(ISessionState session, UnsubscribePacket packet)
{
foreach (string topicToRemove in packet.TopicFilters)
{
session.RemoveSubscription(topicToRemove);
}
var ack = new UnsubAckPacket
{
PacketId = packet.PacketId
};
return(ack);
}
public void OnUnsubAck(IChannelHandlerContext context, UnsubAckPacket packet)
{
pendingUnsubscribes.TryGetValue(packet.PacketId, out PendingUnsubscribe pendingUnsubscribe);
if (pendingUnsubscribe == null)
{
return;
}
pendingUnsubscribe.OnUnsubActReceived();
topicSubscriptions.Remove(pendingUnsubscribe.Topic);
pendingUnsubscribe.Promise.SetResult(null);
pendingUnsubscribes.TryRemove(packet.PacketId, out _);
}
/// <summary>
/// Unsubscribes the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packet">The packet.</param>
public async Task Unsubscribe(IChannelHandlerContext context, UnsubscribePacket packet)
{
var topics = packet.TopicFilters.ToArray();
var deviceId = await _channelService.GetDeviceId(context.Channel);
var message = TransportMessage.CreateInvokeMessage(new RemoteInvokeMessage
{
ServiceId = "Unsubscribe", Parameters = new Dictionary <string, object> {
{ "packet", packet }
}
});
WirteDiagnosticBefore(message, context.Channel.RemoteAddress.ToString(), deviceId, packet.PacketType);
await _channelService.UnSubscribe(deviceId, topics);
await UnsubAck(context, UnsubAckPacket.InResponseTo(packet));
WirteDiagnosticAfter(message);
}
void ProcessUnsubAck(IChannelHandlerContext context, UnsubAckPacket packet)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, context.Name, packet, nameof(ProcessUnsubAck));
}
Contract.Assert(packet != null);
TaskCompletionSource task;
if (this.unsubscribeCompletions.TryRemove(packet.PacketId, out task))
{
task.TryComplete();
}
if (Logging.IsEnabled)
{
Logging.Exit(this, context.Name, packet, nameof(ProcessUnsubAck));
}
}
public static UnsubAckPacket RemoveSubscriptions(ISessionState session, UnsubscribePacket packet)
{
List <Subscription> subscriptions = session.Subscriptions;
foreach (string topicToRemove in packet.TopicFilters)
{
for (int i = subscriptions.Count - 1; i >= 0; i--)
{
if (subscriptions[i].TopicFilter.Equals(topicToRemove, StringComparison.Ordinal))
{
subscriptions.RemoveAt(i);
break;
}
}
}
var ack = new UnsubAckPacket
{
PacketId = packet.PacketId
};
return(ack);
}
public async Task UnsubAck(IChannelHandlerContext context, UnsubAckPacket packet)
{
await context.WriteAndFlushAsync(packet);
}
Packet DecodePacketInternal(IByteBuffer buffer, int packetSignature, ref int remainingLength, IChannelHandlerContext context)
{
if (Signatures.IsPublish(packetSignature))
{
var qualityOfService = (QualityOfService)((packetSignature >> 1) & 0x3); // take bits #1 and #2 ONLY and convert them into QoS value
if (qualityOfService == QualityOfService.Reserved)
{
throw new DecoderException($"Unexpected QoS value of {(int)qualityOfService} for {PacketType.PUBLISH} packet.");
}
bool duplicate = (packetSignature & 0x8) == 0x8; // test bit#3
bool retain = (packetSignature & 0x1) != 0; // test bit#0
var packet = new PublishPacket(qualityOfService, duplicate, retain);
DecodePublishPacket(buffer, packet, ref remainingLength);
return(packet);
}
switch (packetSignature) // strict match checks for valid message type + correct values in flags part
{
case Signatures.PubAck:
var pubAckPacket = new PubAckPacket();
DecodePacketIdVariableHeader(buffer, pubAckPacket, ref remainingLength);
return(pubAckPacket);
case Signatures.PubRec:
var pubRecPacket = new PubRecPacket();
DecodePacketIdVariableHeader(buffer, pubRecPacket, ref remainingLength);
return(pubRecPacket);
case Signatures.PubRel:
var pubRelPacket = new PubRelPacket();
DecodePacketIdVariableHeader(buffer, pubRelPacket, ref remainingLength);
return(pubRelPacket);
case Signatures.PubComp:
var pubCompPacket = new PubCompPacket();
DecodePacketIdVariableHeader(buffer, pubCompPacket, ref remainingLength);
return(pubCompPacket);
case Signatures.PingReq:
this.ValidateServerPacketExpected(packetSignature);
return(PingReqPacket.Instance);
case Signatures.Subscribe:
this.ValidateServerPacketExpected(packetSignature);
var subscribePacket = new SubscribePacket();
DecodePacketIdVariableHeader(buffer, subscribePacket, ref remainingLength);
DecodeSubscribePayload(buffer, subscribePacket, ref remainingLength);
return(subscribePacket);
case Signatures.Unsubscribe:
this.ValidateServerPacketExpected(packetSignature);
var unsubscribePacket = new UnsubscribePacket();
DecodePacketIdVariableHeader(buffer, unsubscribePacket, ref remainingLength);
DecodeUnsubscribePayload(buffer, unsubscribePacket, ref remainingLength);
return(unsubscribePacket);
case Signatures.Connect:
this.ValidateServerPacketExpected(packetSignature);
var connectPacket = new ConnectPacket();
DecodeConnectPacket(buffer, connectPacket, ref remainingLength, context);
return(connectPacket);
case Signatures.Disconnect:
this.ValidateServerPacketExpected(packetSignature);
return(DisconnectPacket.Instance);
case Signatures.ConnAck:
this.ValidateClientPacketExpected(packetSignature);
var connAckPacket = new ConnAckPacket();
DecodeConnAckPacket(buffer, connAckPacket, ref remainingLength);
return(connAckPacket);
case Signatures.SubAck:
this.ValidateClientPacketExpected(packetSignature);
var subAckPacket = new SubAckPacket();
DecodePacketIdVariableHeader(buffer, subAckPacket, ref remainingLength);
DecodeSubAckPayload(buffer, subAckPacket, ref remainingLength);
return(subAckPacket);
case Signatures.UnsubAck:
this.ValidateClientPacketExpected(packetSignature);
var unsubAckPacket = new UnsubAckPacket();
DecodePacketIdVariableHeader(buffer, unsubAckPacket, ref remainingLength);
return(unsubAckPacket);
case Signatures.PingResp:
this.ValidateClientPacketExpected(packetSignature);
return(PingRespPacket.Instance);
default:
throw new DecoderException($"First packet byte value of `{packetSignature}` is invalid.");
}
}
Packet DecodePacketInternal(IByteBuffer buffer, int packetSignature, ref int remainingLength, IChannelHandlerContext context)
{
if (Signatures.IsPublish(packetSignature))
{
var qualityOfService = (QualityOfService)((packetSignature >> 1) & 0x3); // take bits #1 and #2 ONLY and convert them into QoS value
if (qualityOfService == QualityOfService.Reserved)
{
ThrowHelper.ThrowDecoderException_UnexpectedQoSValueForPublish(qualityOfService);
}
bool duplicate = (packetSignature & 0x8) == 0x8; // test bit#3
bool retain = (packetSignature & 0x1) != 0; // test bit#0
var packet = new PublishPacket(qualityOfService, duplicate, retain);
DecodePublishPacket(buffer, packet, ref remainingLength);
return(packet);
}
switch (packetSignature) // strict match checks for valid message type + correct values in flags part
{
case Signatures.PubAck:
var pubAckPacket = new PubAckPacket();
DecodePacketIdVariableHeader(buffer, pubAckPacket, ref remainingLength);
return(pubAckPacket);
case Signatures.PubRec:
var pubRecPacket = new PubRecPacket();
DecodePacketIdVariableHeader(buffer, pubRecPacket, ref remainingLength);
return(pubRecPacket);
case Signatures.PubRel:
var pubRelPacket = new PubRelPacket();
DecodePacketIdVariableHeader(buffer, pubRelPacket, ref remainingLength);
return(pubRelPacket);
case Signatures.PubComp:
var pubCompPacket = new PubCompPacket();
DecodePacketIdVariableHeader(buffer, pubCompPacket, ref remainingLength);
return(pubCompPacket);
case Signatures.PingReq:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
return(PingReqPacket.Instance);
case Signatures.Subscribe:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
var subscribePacket = new SubscribePacket();
DecodePacketIdVariableHeader(buffer, subscribePacket, ref remainingLength);
DecodeSubscribePayload(buffer, subscribePacket, ref remainingLength);
return(subscribePacket);
case Signatures.Unsubscribe:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
var unsubscribePacket = new UnsubscribePacket();
DecodePacketIdVariableHeader(buffer, unsubscribePacket, ref remainingLength);
DecodeUnsubscribePayload(buffer, unsubscribePacket, ref remainingLength);
return(unsubscribePacket);
case Signatures.Connect:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
var connectPacket = new ConnectPacket();
DecodeConnectPacket(buffer, connectPacket, ref remainingLength, context);
return(connectPacket);
case Signatures.Disconnect:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
return(DisconnectPacket.Instance);
case Signatures.ConnAck:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
var connAckPacket = new ConnAckPacket();
DecodeConnAckPacket(buffer, connAckPacket, ref remainingLength);
return(connAckPacket);
case Signatures.SubAck:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
var subAckPacket = new SubAckPacket();
DecodePacketIdVariableHeader(buffer, subAckPacket, ref remainingLength);
DecodeSubAckPayload(buffer, subAckPacket, ref remainingLength);
return(subAckPacket);
case Signatures.UnsubAck:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
var unsubAckPacket = new UnsubAckPacket();
DecodePacketIdVariableHeader(buffer, unsubAckPacket, ref remainingLength);
return(unsubAckPacket);
case Signatures.PingResp:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
return(PingRespPacket.Instance);
default:
return(ThrowHelper.FromDecoderException_FirstPacketByteValueIsInvalid(packetSignature));
}
}
public static Packet DecodePacket(DataReader reader)
{
reader.ByteOrder = ByteOrder.BigEndian;
int signature = reader.ReadByte();
int remainingLength = DecodeRemainingLength(reader);
if (Signatures.IsPublish(signature))
{
var qualityOfService =
(QualityOfService)((signature >> 1) &
0x3); // take bits #1 and #2 ONLY and convert them into QoS value
if (qualityOfService == QualityOfService.Reserved)
{
throw new Exception(
$"Unexpected QoS value of {(int)qualityOfService} for {PacketType.PUBLISH} packet.");
}
bool duplicate = (signature & 0x8) == 0x8; // test bit#3
bool retain = (signature & 0x1) != 0; // test bit#0
var packet = new PublishPacket(qualityOfService, duplicate, retain);
DecodePublishPacket(reader, packet, ref remainingLength);
return(packet);
}
switch (signature & 240) // We don't care about flags for these packets
{
// case Signatures.Subscribe & 240:
// var subscribePacket = new SubscribePacket();
// DecodePacketIdVariableHeader(reader, subscribePacket, ref remainingLength);
// DecodeSubscribePayload(buffer, subscribePacket, ref remainingLength);
// return subscribePacket;
case Signatures.Connect:
var connectPacket = new ConnectPacket();
DecodeConnectPacket(reader, connectPacket, ref remainingLength);
return(connectPacket);
case Signatures.PubAck:
var pubAckPacket = new PubAckPacket();
DecodePacketIdVariableHeader(reader, pubAckPacket, ref remainingLength);
return(pubAckPacket);
case Signatures.ConnAck:
var connAckPacket = new FbnsConnAckPacket();
DecodeConnAckPacket(reader, connAckPacket, ref remainingLength);
return(connAckPacket);
case Signatures.SubAck:
var subAckPacket = new SubAckPacket();
DecodePacketIdVariableHeader(reader, subAckPacket, ref remainingLength);
DecodeSubAckPayload(reader, subAckPacket, ref remainingLength);
return(subAckPacket);
case Signatures.UnsubAck:
var unsubAckPacket = new UnsubAckPacket();
DecodePacketIdVariableHeader(reader, unsubAckPacket, ref remainingLength);
return(unsubAckPacket);
case Signatures.PingResp:
return(PingRespPacket.Instance);
default:
throw new Exception($"Packet type {signature} not supported");
}
}
public abstract void UnsubAck(IChannelHandlerContext context, UnsubAckPacket packet);
private void HandleUnsuback(UnsubAckPacket message)
{
}
private void ProcessMessage(UnsubAckPacket message)
{
}
