/// <summary>
/// Parse bytes for a PUBCOMP 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>PUBCOMP message instance</returns>
public static MqttPublishCompleteMessage Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttPublishCompleteMessage msg = new MqttPublishCompleteMessage();
if (protocolVersion == MqttConnectMessage.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBCOMP_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);
// message id
msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
msg.messageId |= (buffer[index++]);
return(msg);
}
public void ValidPayload()
{
// Message Specs________________
// <40><02><00><04> (Pub complete for Message ID 4)
var sampleMessage = new[]
{
(byte)0x70,
(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 <MqttPublishCompleteMessage>(baseMessage);
MqttPublishCompleteMessage message = (MqttPublishCompleteMessage)baseMessage;
// validate the message deserialization
Assert.Equal <MqttMessageType>(MqttMessageType.PublishComplete, 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);
}
public void BasicSerialization()
{
var expected = new[]
{
(byte)0x70,
(byte)0x02,
(byte)0x0,
(byte)0x4,
};
MqttPublishCompleteMessage msg = new MqttPublishCompleteMessage().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.
}
public virtual void Route(byte[] messageData, T session)
{
try
{
MqttMessage incoming = MqttMessage.CreateFrom(messageData);
switch (incoming.Header.MessageType)
{
case MqttMessageType.Publish:
PublishReceived(session, (MqttPublishMessage)incoming);
break;
case MqttMessageType.Subscribe:
SubscribeReceived(session, (MqttSubscribeMessage)incoming);
break;
case MqttMessageType.Unsubscribe:
RemoveSubscriptions(session, ((MqttUnsubscribeMessage)incoming).Payload.Subscriptions);
var unsubAck = new MqttUnsubscribeAckMessage().WithMessageIdentifier(((MqttPublishReceivedMessage)incoming).VariableHeader.MessageIdentifier);
session.Write(unsubAck);
break;
case MqttMessageType.PublishAck:
string messageId = session.PublishAcknowledged(((MqttPublishAckMessage)incoming).VariableHeader.MessageIdentifier);
if (messageId != null)
{
storageProvider.ReleaseMessage(messageId);
}
break;
case MqttMessageType.PublishReceived:
messageId = session.PublishReceived(((MqttPublishReceivedMessage)incoming).VariableHeader.MessageIdentifier);
if (messageId != null)
{
storageProvider.ReleaseMessage(messageId);
}
break;
case MqttMessageType.PublishRelease:
session.RemoveQoS2(((MqttPublishReleaseMessage)incoming).VariableHeader.MessageIdentifier);
var pubComp = new MqttPublishCompleteMessage().WithMessageIdentifier(((MqttPublishReleaseMessage)incoming).VariableHeader.MessageIdentifier);
session.Write(pubComp);
break;
case MqttMessageType.PublishComplete:
session.PublishCompleted(((MqttPublishCompleteMessage)incoming).VariableHeader.MessageIdentifier);
break;
}
}
catch (TargetInvocationException ex)
{
var inner = ex.InnerException as HttpException;
session.Write(inner != null ? new ErrorMessage(inner.GetHttpCode(), inner.Message) : new ErrorMessage((ex.InnerException ?? ex).Message));
}
catch (HttpException ex)
{
session.Write(new ErrorMessage(ex.Message));
}
catch (Exception ex)
{
session.Write(new ErrorMessage(ex.Message));
}
}
