async void RetransmitPublishMessage(IChannelHandlerContext context, Message message, AckPendingMessageState messageInfo)
{
try
{
using (message)
{
string topicName;
var completeContext = new ReadOnlyMergeDictionary <string, string>(this.sessionContext, message.Properties);
if (!this.topicNameRouter.TryMapRouteToTopicName(RouteSourceType.Notification, completeContext, out topicName))
{
throw new InvalidOperationException("Route mapping failed on retransmission.");
}
PublishPacket packet = await Util.ComposePublishPacketAsync(context, message, messageInfo.QualityOfService, topicName);
messageInfo.ResetMessage(message);
await this.publishPubAckProcessor.RetransmitAsync(context, packet, messageInfo);
}
}
catch (Exception ex)
{
// todo: log more details
ShutdownOnError(context, "<- PUBLISH (retransmission)", ex);
}
}
async void RetransmitPublishMessage(IChannelHandlerContext context, Message message, AckPendingMessageState messageInfo)
{
try
{
using (message)
{
string topicName;
var completeContext = new ReadOnlyMergeDictionary<string, string>(this.sessionContext, message.Properties);
if (!this.topicNameRouter.TryMapRouteToTopicName(RouteSourceType.Notification, completeContext, out topicName))
{
throw new InvalidOperationException("Route mapping failed on retransmission.");
}
PublishPacket packet = await Util.ComposePublishPacketAsync(context, message, messageInfo.QualityOfService, topicName);
messageInfo.ResetMessage(message);
await this.publishPubAckProcessor.RetransmitAsync(context, packet, messageInfo);
}
}
catch (Exception ex)
{
// todo: log more details
ShutdownOnError(context, "<- PUBLISH (retransmission)", ex);
}
}
async Task PublishToClientAsync(IChannelHandlerContext context, Message message)
{
try
{
using (message)
{
if (this.settings.MaxOutboundRetransmissionEnforced && message.DeliveryCount > this.settings.MaxOutboundRetransmissionCount)
{
await this.RejectMessageAsync(message);
return;
}
string topicName;
var completeContext = new ReadOnlyMergeDictionary<string, string>(this.sessionContext, message.Properties);
if (!this.topicNameRouter.TryMapRouteToTopicName(RouteSourceType.Notification, completeContext, out topicName))
{
// source is not configured
await this.RejectMessageAsync(message);
return;
}
QualityOfService qos;
QualityOfService maxRequestedQos;
if (this.TryMatchSubscription(topicName, message.EnqueuedTimeUtc, out maxRequestedQos))
{
qos = Util.DeriveQos(message, this.settings);
if (maxRequestedQos < qos)
{
qos = maxRequestedQos;
}
}
else
{
// no matching subscription found - complete the message without publishing
await this.RejectMessageAsync(message);
return;
}
PublishPacket packet = await Util.ComposePublishPacketAsync(context, message, qos, topicName);
switch (qos)
{
case QualityOfService.AtMostOnce:
await this.PublishToClientQos0Async(context, message, packet);
break;
case QualityOfService.AtLeastOnce:
await this.PublishToClientQos1Async(context, message, packet);
break;
case QualityOfService.ExactlyOnce:
if (this.maxSupportedQosToClient >= QualityOfService.ExactlyOnce)
{
await this.PublishToClientQos2Async(context, message, packet);
}
else
{
throw new InvalidOperationException("Requested QoS level is not supported.");
}
break;
default:
throw new InvalidOperationException("Requested QoS level is not supported.");
}
}
}
catch (Exception ex)
{
// todo: log more details
ShutdownOnError(context, "<- PUBLISH", ex);
}
}
async Task PublishToClientAsync(IChannelHandlerContext context, Message message)
{
try
{
using (message)
{
if (this.settings.MaxOutboundRetransmissionEnforced && message.DeliveryCount > this.settings.MaxOutboundRetransmissionCount)
{
await this.RejectMessageAsync(message);
return;
}
string topicName;
var completeContext = new ReadOnlyMergeDictionary <string, string>(this.sessionContext, message.Properties);
if (!this.topicNameRouter.TryMapRouteToTopicName(RouteSourceType.Notification, completeContext, out topicName))
{
// source is not configured
await this.RejectMessageAsync(message);
return;
}
QualityOfService qos;
QualityOfService maxRequestedQos;
if (this.TryMatchSubscription(topicName, message.EnqueuedTimeUtc, out maxRequestedQos))
{
qos = Util.DeriveQos(message, this.settings);
if (maxRequestedQos < qos)
{
qos = maxRequestedQos;
}
}
else
{
// no matching subscription found - complete the message without publishing
await this.RejectMessageAsync(message);
return;
}
PublishPacket packet = await Util.ComposePublishPacketAsync(context, message, qos, topicName);
switch (qos)
{
case QualityOfService.AtMostOnce:
await this.PublishToClientQos0Async(context, message, packet);
break;
case QualityOfService.AtLeastOnce:
await this.PublishToClientQos1Async(context, message, packet);
break;
case QualityOfService.ExactlyOnce:
if (this.maxSupportedQosToClient >= QualityOfService.ExactlyOnce)
{
await this.PublishToClientQos2Async(context, message, packet);
}
else
{
throw new InvalidOperationException("Requested QoS level is not supported.");
}
break;
default:
throw new InvalidOperationException("Requested QoS level is not supported.");
}
}
}
catch (Exception ex)
{
// todo: log more details
ShutdownOnError(context, "<- PUBLISH", ex);
}
}
