void ProcessMessage(IChannelHandlerContext context, Packet packet)
{
if (this.IsInState(StateFlags.Closed))
{
return;
}
switch (packet.PacketType)
{
case PacketType.CONNACK:
this.ProcessConnectAck(context, (ConnAckPacket)packet);
break;
case PacketType.SUBACK:
this.ProcessSubAck();
break;
case PacketType.PUBLISH:
this.ProcessPublish(context, (PublishPacket)packet);
break;
case PacketType.PUBACK:
this.serviceBoundTwoWayProcessor.CompleteWorkAsync(context, ((PubAckPacket)packet).PacketId);
break;
case PacketType.PINGRESP:
break;
default:
ShutdownOnError(context);
break;
}
}
void HandleSubscriptionChange(IChannelHandlerContext context, Packet packet)
{
this.SubscriptionChangeQueue.Enqueue(packet);
if (!this.IsInState(StateFlags.ChangingSubscriptions))
{
this.stateFlags |= StateFlags.ChangingSubscriptions;
this.ProcessPendingSubscriptionChanges(context);
}
}
async void ProcessMessage(IChannelHandlerContext context, Packet packet)
{
if (this.IsInState(StateFlags.Closed))
{
return;
}
try
{
switch (packet.PacketType)
{
case PacketType.CONNACK:
await this.ProcessConnectAckAsync(context, (ConnAckPacket)packet);
break;
case PacketType.SUBACK:
this.ProcessSubAck();
break;
case PacketType.PUBLISH:
this.ProcessPublish(context, (PublishPacket)packet);
break;
case PacketType.PUBACK:
await this.serviceBoundTwoWayProcessor.CompleteWorkAsync(context, ((PubAckPacket)packet).PacketId);
break;
case PacketType.PINGRESP:
break;
default:
ShutdownOnError(context, new InvalidOperationException($"Unexpected packet type {packet.PacketType}"));
break;
}
}
catch (Exception ex) when(!ex.IsFatal())
{
ShutdownOnError(context, ex);
}
}
void ProcessMessage(IChannelHandlerContext context, Packet packet)
{
if (this.IsInState(StateFlags.Closed))
{
MqttIotHubAdapterEventSource.Log.Warning(string.Format("Message was received after channel closure: {0}", packet));
return;
}
PerformanceCounters.PacketsReceivedPerSecond.Increment();
switch (packet.PacketType)
{
case PacketType.CONNECT:
this.Connect(context, (ConnectPacket)packet);
break;
case PacketType.PUBLISH:
PerformanceCounters.PublishPacketsReceivedPerSecond.Increment();
this.publishProcessor.Post(context, (PublishPacket)packet);
break;
case PacketType.PUBACK:
this.publishPubAckProcessor.Post(context, (PubAckPacket)packet);
break;
case PacketType.PUBREC:
this.publishPubRecProcessor.Post(context, (PubRecPacket)packet);
break;
case PacketType.PUBCOMP:
this.pubRelPubCompProcessor.Post(context, (PubCompPacket)packet);
break;
case PacketType.SUBSCRIBE:
case PacketType.UNSUBSCRIBE:
this.HandleSubscriptionChange(context, packet);
break;
case PacketType.PINGREQ:
// no further action is needed - keep-alive "timer" was reset by now
Util.WriteMessageAsync(context, PingRespPacket.Instance)
.OnFault(ShutdownOnWriteFaultAction, context);
break;
case PacketType.DISCONNECT:
MqttIotHubAdapterEventSource.Log.Verbose("Disconnecting gracefully.", this.deviceId);
this.Shutdown(context, true);
break;
default:
ShutdownOnError(context, string.Format("Packet of unsupported type was observed: {0}", packet));
break;
}
}
static IEnumerable<TestScenarioStep> GetClientScenario(Func<object> currentMessageFunc, string iotHubName, string clientId, string password)
{
yield return TestScenarioStep.Write(new ConnectPacket
{
ClientId = clientId,
HasUsername = true,
Username = iotHubName + "/" + clientId,
HasPassword = true,
Password = password,
KeepAliveInSeconds = 120,
HasWill = true,
WillTopicName = "last/word",
WillMessage = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("oops"))
});
var connAckPacket = Assert.IsType<ConnAckPacket>(currentMessageFunc());
Assert.Equal(ConnectReturnCode.Accepted, connAckPacket.ReturnCode);
int subscribePacketId = GetRandomPacketId();
yield return TestScenarioStep.Write(new SubscribePacket
{
PacketId = subscribePacketId,
Requests = new[]
{
new SubscriptionRequest(string.Format("devices/{0}/messages/devicebound/#", clientId), QualityOfService.ExactlyOnce)
}
});
var subAckPacket = Assert.IsType<SubAckPacket>(currentMessageFunc());
Assert.Equal(subscribePacketId, subAckPacket.PacketId);
Assert.Equal(1, subAckPacket.ReturnCodes.Count);
Assert.Equal(QualityOfService.ExactlyOnce, subAckPacket.ReturnCodes[0]);
int publishQoS1PacketId = GetRandomPacketId();
yield return TestScenarioStep.Write(
new PublishPacket(QualityOfService.AtMostOnce, false, false)
{
//TopicName = string.Format("devices/{0}/messages/log/verbose/", clientId),
TopicName = string.Format("devices/{0}/messages/events", clientId),
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("{\"test\": \"telemetry-QoS0\"}"))
},
new PublishPacket(QualityOfService.AtLeastOnce, false, false)
{
PacketId = publishQoS1PacketId,
TopicName = string.Format("devices/{0}/messages/events", clientId),
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("{\"test\": \"telemetry\"}"))
});
var packets = new Packet[4];
for (int i = packets.Length - 1; i >= 0; i--)
{
packets[i] = Assert.IsAssignableFrom<Packet>(currentMessageFunc());
if (i > 0)
{
yield return TestScenarioStep.ReadMore();
}
}
PubAckPacket pubAckPacket = Assert.Single(packets.OfType<PubAckPacket>());
Assert.Equal(publishQoS1PacketId, pubAckPacket.PacketId);
PublishPacket publishQoS0Packet = Assert.Single(packets.OfType<PublishPacket>().Where(x => x.QualityOfService == QualityOfService.AtMostOnce));
//Assert.Equal(string.Format("devices/{0}/messages/devicebound/tips", clientId), publishQoS0Packet.TopicName);
Assert.Equal(string.Format("devices/{0}/messages/devicebound", clientId), publishQoS0Packet.TopicName);
Assert.Equal(NotificationQoS0Content, Encoding.UTF8.GetString(publishQoS0Packet.Payload.ToArray()));
PublishPacket publishQoS1Packet = Assert.Single(packets.OfType<PublishPacket>().Where(x => x.QualityOfService == QualityOfService.AtLeastOnce));
//Assert.Equal(string.Format("devices/{0}/messages/devicebound/firmware-update", clientId), publishQoS1Packet.TopicName);
Assert.Equal(string.Format("devices/{0}/messages/devicebound", clientId), publishQoS1Packet.TopicName);
Assert.Equal(NotificationQoS1Content, Encoding.UTF8.GetString(publishQoS1Packet.Payload.ToArray()));
PublishPacket publishQoS2Packet = Assert.Single(packets.OfType<PublishPacket>().Where(x => x.QualityOfService == QualityOfService.ExactlyOnce));
//Assert.Equal(string.Format("devices/{0}/messages/devicebound/critical-alert", clientId), publishQoS2Packet.TopicName);
Assert.Equal(string.Format("devices/{0}/messages/devicebound", clientId), publishQoS2Packet.TopicName);
Assert.Equal(NotificationQoS2Content, Encoding.UTF8.GetString(publishQoS2Packet.Payload.ToArray()));
yield return TestScenarioStep.Write(
PubAckPacket.InResponseTo(publishQoS1Packet),
PubRecPacket.InResponseTo(publishQoS2Packet));
var pubRelQoS2Packet = Assert.IsAssignableFrom<PubRelPacket>(currentMessageFunc());
Assert.Equal(publishQoS2Packet.PacketId, pubRelQoS2Packet.PacketId);
yield return TestScenarioStep.Write(
false, // it is a final step and we do not expect response
PubCompPacket.InResponseTo(pubRelQoS2Packet),
DisconnectPacket.Instance);
}