public CompletionPendingMessageState(int packetId, IQos2MessageDeliveryState deliveryState,
PreciseTimeSpan startTimestamp, MessageFeedbackChannel feedbackChannel)
{
this.PacketId = packetId;
this.DeliveryState = deliveryState;
this.StartTimestamp = startTimestamp;
this.FeedbackChannel = feedbackChannel;
}
public CompletionPendingMessageState(int packetId, string lockToken,
IQos2MessageDeliveryState deliveryState, PreciseTimeSpan startTimestamp)
{
this.PacketId = packetId;
this.LockToken = lockToken;
this.DeliveryState = deliveryState;
this.StartTimestamp = startTimestamp;
this.SentTime = DateTime.UtcNow;
}
public CompletionPendingMessageState(int packetId, string lockToken,
IQos2MessageDeliveryState deliveryState, PreciseTimeSpan startTimestamp)
{
this.PacketId = packetId;
this.LockToken = lockToken;
this.DeliveryState = deliveryState;
this.StartTimestamp = startTimestamp;
this.SentTime = DateTime.UtcNow;
}
public CompletionPendingMessageState(int packetId, IQos2MessageDeliveryState deliveryState,
PreciseTimeSpan startTimestamp, MessageFeedbackChannel feedbackChannel)
{
this.PacketId = packetId;
this.DeliveryState = deliveryState;
this.StartTimestamp = startTimestamp;
this.FeedbackChannel = feedbackChannel;
this.SentTime = DateTime.UtcNow;
}
Task PublishReleaseToClientAsync(IChannelHandlerContext context, int packetId, MessageFeedbackChannel feedbackChannel,
IQos2MessageDeliveryState messageState, PreciseTimeSpan startTimestamp)
{
var pubRelPacket = new PubRelPacket();
pubRelPacket.PacketId = packetId;
return(this.pubRelPubCompProcessor.SendRequestAsync(context, pubRelPacket,
new CompletionPendingMessageState(packetId, messageState, startTimestamp, feedbackChannel)));
}
Task PublishReleaseToClientAsync(IChannelHandlerContext context, int packetId, string lockToken,
IQos2MessageDeliveryState messageState, PreciseTimeSpan startTimestamp)
{
var pubRelPacket = new PubRelPacket
{
PacketId = packetId
};
return(this.pubRelPubCompProcessor.SendRequestAsync(context, pubRelPacket,
new CompletionPendingMessageState(packetId, lockToken, messageState, startTimestamp)));
}
static TableMessageDeliveryState ValidateMessageType(IQos2MessageDeliveryState message)
{
var tableMessage = message as TableMessageDeliveryState;
if (tableMessage == null)
{
throw new ArgumentException(string.Format("Message is of unexpected type `{0}`. Only messages created through {1}.Create() method are supported",
message.GetType().Name, typeof(TableQos2StatePersistenceProvider).Name));
}
return(tableMessage);
}
public Task DeleteMessageAsync(int packetId, IQos2MessageDeliveryState message)
{
Contract.Requires(message != null);
TableMessageDeliveryState tableMessage = ValidateMessageType(message);
if (tableMessage.ETag == null)
{
throw new ArgumentException("Transient message cannot be deleted.");
}
return this.table.ExecuteAsync(TableOperation.Delete(tableMessage));
}
public Task DeleteMessageAsync(IDeviceIdentity deviceIdentity, int packetId, IQos2MessageDeliveryState message)
{
Contract.Requires(message != null);
TableMessageDeliveryState tableMessage = ValidateMessageType(message);
if (tableMessage.ETag == null)
{
throw new ArgumentException("Transient message cannot be deleted.");
}
return(this.table.ExecuteAsync(TableOperation.Delete(tableMessage)));
}
async Task AcknowledgePublishReceiveAsync(IChannelHandlerContext context, AckPendingMessageState message)
{
this.ResumeReadingIfNecessary(context);
// todo: is try-catch needed here?
try
{
IQos2MessageDeliveryState messageInfo = this.qos2StateProvider.Create(message.SequenceNumber);
await this.qos2StateProvider.SetMessageAsync(this.identity, message.PacketId, messageInfo);
await this.PublishReleaseToClientAsync(context, message.PacketId, message.FeedbackChannel, messageInfo, message.StartTimestamp);
}
catch (Exception ex)
{
ShutdownOnError(context, "-> PUBREC", ex);
}
}
public Task SetMessageAsync(int packetId, IQos2MessageDeliveryState message)
{
Contract.Requires(message != null);
TableMessageDeliveryState tableMessage = ValidateMessageType(message);
TableOperation tableOperation;
if (tableMessage.ETag == null)
{
tableMessage.PartitionKey = CalculatePartitionKey(packetId);
tableMessage.RowKey = packetId.ToString(CultureInfo.InvariantCulture);
tableOperation = TableOperation.Insert(tableMessage);
}
else
{
tableOperation = TableOperation.Replace(tableMessage);
}
return(this.table.ExecuteAsync(tableOperation));
}
public Task SetMessageAsync(IDeviceIdentity deviceIdentity, int packetId, IQos2MessageDeliveryState message)
{
Contract.Requires(message != null);
TableMessageDeliveryState tableMessage = ValidateMessageType(message);
TableOperation tableOperation;
if (tableMessage.ETag == null)
{
string rowKey = CalculateRowKey(deviceIdentity.Id, packetId);
tableMessage.PartitionKey = CalculatePartitionKey(rowKey);
tableMessage.RowKey = rowKey;
tableOperation = TableOperation.Insert(tableMessage);
}
else
{
tableOperation = TableOperation.Replace(tableMessage);
}
return(this.table.ExecuteAsync(tableOperation));
}
async Task PublishToClientQos2Async(IChannelHandlerContext context, IMessage message, PublishPacket packet)
{
int packetId = packet.PacketId;
IQos2MessageDeliveryState messageInfo = await this.qos2StateProvider.GetMessageAsync(this.identity, packetId);
if (messageInfo != null && message.SequenceNumber != messageInfo.SequenceNumber)
{
await this.qos2StateProvider.DeleteMessageAsync(this.identity, packetId, messageInfo);
messageInfo = null;
}
if (messageInfo == null)
{
await this.publishPubRecProcessor.SendRequestAsync(context, packet, new AckPendingMessageState(message, packet));
}
else
{
await this.PublishReleaseToClientAsync(context, packetId, message.LockToken, messageInfo, PreciseTimeSpan.FromStart);
}
}
async Task PublishToClientQos2Async(IChannelHandlerContext context, Message message, PublishPacket packet)
{
int packetId = packet.PacketId;
IQos2MessageDeliveryState messageInfo = await this.qos2StateProvider.GetMessageAsync(packetId);
if (messageInfo != null && !message.MessageId.Equals(messageInfo.MessageId, StringComparison.Ordinal))
{
await this.qos2StateProvider.DeleteMessageAsync(packetId, messageInfo);
messageInfo = null;
}
if (messageInfo == null)
{
await this.publishPubRecProcessor.SendRequestAsync(context, packet, new AckPendingMessageState(message, packet));
}
else
{
await this.PublishReleaseToClientAsync(context, packetId, message.LockToken, messageInfo, PreciseTimeSpan.FromStart);
}
}
async Task PublishToClientQos2Async(IChannelHandlerContext context, IMessage message, IMessagingSource callback, PublishPacket packet)
{
await Qos2Semaphore.WaitAsync(this.lifetimeCancellation.Token); // this ensures proper ordering of messages
Task deliveryTask;
try
{
int packetId = packet.PacketId;
IQos2MessageDeliveryState messageInfo = await this.qos2StateProvider.GetMessageAsync(this.identity, packetId);
if (messageInfo != null && message.SequenceNumber != messageInfo.SequenceNumber)
{
await this.qos2StateProvider.DeleteMessageAsync(this.identity, packetId, messageInfo);
messageInfo = null;
}
if (messageInfo == null)
{
deliveryTask = this.publishPubRecProcessor.SendRequestAsync(context, packet,
new AckPendingMessageState(message, callback, packet));
}
else
{
deliveryTask = this.PublishReleaseToClientAsync(context, packetId, new MessageFeedbackChannel(message.Id, callback), messageInfo, PreciseTimeSpan.FromStart);
}
}
finally
{
try
{
this.Qos2Semaphore.Release();
}
catch (ObjectDisposedException)
{ }
}
await deliveryTask;
}
async Task AcknowledgePublishReceiveAsync(IChannelHandlerContext context, AckPendingMessageState message)
{
this.ResumeReadingIfNecessary(context);
// todo: is try-catch needed here?
try
{
IQos2MessageDeliveryState messageInfo = this.qos2StateProvider.Create(message.MessageId);
await this.qos2StateProvider.SetMessageAsync(message.PacketId, messageInfo);
await this.PublishReleaseToClientAsync(context, message.PacketId, message.LockToken, messageInfo, message.StartTimestamp);
if (this.publishPubRecProcessor.ResumeRetransmission(context))
{
return;
}
this.RestartReceiveIfPossible(context);
}
catch (Exception ex)
{
ShutdownOnError(context, "-> PUBREC", ex);
}
}
static TableMessageDeliveryState ValidateMessageType(IQos2MessageDeliveryState message)
{
var tableMessage = message as TableMessageDeliveryState;
if (tableMessage == null)
{
throw new ArgumentException(string.Format("Message is of unexpected type `{0}`. Only messages created through {1}.Create() method are supported",
message.GetType().Name, typeof(TableQos2StatePersistenceProvider).Name));
}
return tableMessage;
}
public Task SetMessageAsync(IDeviceIdentity deviceIdentity, int packetId, IQos2MessageDeliveryState message)
{
Contract.Requires(message != null);
TableMessageDeliveryState tableMessage = ValidateMessageType(message);
TableOperation tableOperation;
if (tableMessage.ETag == null)
{
string rowKey = CalculateRowKey(deviceIdentity.Id, packetId);
tableMessage.PartitionKey = CalculatePartitionKey(rowKey);
tableMessage.RowKey = rowKey;
tableOperation = TableOperation.Insert(tableMessage);
}
else
{
tableOperation = TableOperation.Replace(tableMessage);
}
return this.table.ExecuteAsync(tableOperation);
}
public Task SetMessageAsync(int packetId, IQos2MessageDeliveryState message)
{
Contract.Requires(message != null);
TableMessageDeliveryState tableMessage = ValidateMessageType(message);
TableOperation tableOperation;
if (tableMessage.ETag == null)
{
tableMessage.PartitionKey = CalculatePartitionKey(packetId);
tableMessage.RowKey = packetId.ToString(CultureInfo.InvariantCulture);
tableOperation = TableOperation.Insert(tableMessage);
}
else
{
tableOperation = TableOperation.Replace(tableMessage);
}
return this.table.ExecuteAsync(tableOperation);
}
Task PublishReleaseToClientAsync(IChannelHandlerContext context, int packetId, string lockToken,
IQos2MessageDeliveryState messageState, PreciseTimeSpan startTimestamp)
{
var pubRelPacket = new PubRelPacket
{
PacketId = packetId
};
return this.pubRelPubCompProcessor.SendRequestAsync(context, pubRelPacket,
new CompletionPendingMessageState(packetId, lockToken, messageState, startTimestamp));
}