public void ValidPayload()
{
// Message Specs________________
// <40><02><00><04> (Pub Release for Message ID 4)
var sampleMessage = new[]
{
(byte)0x60,
(byte)0x02,
(byte)0x0,
(byte)0x4,
};
MqttMessage baseMessage = MqttMessage.CreateFrom(sampleMessage);
Console.WriteLine(baseMessage.ToString());
// check that the message was correctly identified as a connect message.
Assert.IsType <MqttPublishReleaseMessage>(baseMessage);
MqttPublishReleaseMessage message = (MqttPublishReleaseMessage)baseMessage;
// validate the message deserialization
Assert.Equal <MqttMessageType>(MqttMessageType.PublishRelease, message.Header.MessageType);
Assert.Equal <int>(2, message.Header.MessageSize);
// make sure the publish message length matches the expectred size.
Assert.Equal <int>(4, message.VariableHeader.MessageIdentifier);
}
internal void PublishReceived(IMqttSession session, MqttPublishMessage publishMessage)
{
if (publishMessage.Header.Qos == MqttQos.BestEffort && session.HasQoS2(publishMessage.VariableHeader.MessageIdentifier))
{
var pubRec = new MqttPublishReceivedMessage()
.WithMessageIdentifier(publishMessage.VariableHeader.MessageIdentifier);
session.Write(pubRec);
}
if (publishMessage.Header.Retain)
{
this.storageProvider.PutRetained(publishMessage.VariableHeader.TopicName, publishMessage.Payload.Message.ToArray());
}
PublishMessage(GetSubscriptions(publishMessage.VariableHeader.TopicName), publishMessage.VariableHeader.TopicName, publishMessage.Payload.Message.ToArray());
switch (publishMessage.Header.Qos)
{
case MqttQos.AtLeastOnce:
var puback = new MqttPublishAckMessage().WithMessageIdentifier(publishMessage.VariableHeader.MessageIdentifier);
session.Write(puback);
break;
case MqttQos.AtMostOnce:
session.StoreQoS2(publishMessage.VariableHeader.MessageIdentifier);
var pubRec = new MqttPublishReleaseMessage().WithMessageIdentifier(publishMessage.VariableHeader.MessageIdentifier);
session.Write(pubRec);
break;
case MqttQos.BestEffort:
default:
break;
}
}
/// <summary>
/// Parse bytes for a PUBREL message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBREL message instance</returns>
public static MqttPublishReleaseMessage Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttPublishReleaseMessage msg = new MqttPublishReleaseMessage();
if (protocolVersion == MqttConnectMessage.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBREL_FLAG_BITS)
{
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
}
// get remaining length and allocate buffer
int remainingLength = MqttMessage.DecodeRemainingLength(channel);
buffer = new byte[remainingLength];
// read bytes from socket...
channel.Receive(buffer);
if (protocolVersion == MqttConnectMessage.PROTOCOL_VERSION_V3_1)
{
// only 3.1.0
// read QoS level from fixed header (would be QoS Level 1)
msg.qosLevel = (byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
// read DUP flag from fixed header
msg.dupFlag = (((fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET) == 0x01);
}
// message id
msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
msg.messageId |= (buffer[index++]);
return(msg);
}
public void BasicSerialization()
{
var expected = new[]
{
(byte)0x60,
(byte)0x02,
(byte)0x0,
(byte)0x4,
};
MqttPublishReleaseMessage msg = new MqttPublishReleaseMessage().WithMessageIdentifier(4);
Console.WriteLine(msg.ToString());
byte[] actual = MessageSerializationHelper.GetMessageBytes(msg);
Assert.Equal <int>(expected.Length, actual.Length);
Assert.Equal <byte>(expected[0], actual[0]); // msg type of header
Assert.Equal <byte>(expected[1], actual[1]); // remaining length
Assert.Equal <byte>(expected[2], actual[2]); // connect ack - compression? always empty
Assert.Equal <byte>(expected[3], actual[3]); // return code.
}
