byte[] GetPayload(Subscribe packet)
{
if (packet.Subscriptions == null || !packet.Subscriptions.Any())
{
throw new MqttProtocolViolationException(Properties.Resources.SubscribeFormatter_MissingTopicFilterQosPair);
}
var payload = new List <byte> ();
foreach (var subscription in packet.Subscriptions)
{
if (string.IsNullOrEmpty(subscription.TopicFilter))
{
throw new MqttProtocolViolationException(Properties.Resources.SubscribeFormatter_MissingTopicFilterQosPair);
}
if (!topicEvaluator.IsValidTopicFilter(subscription.TopicFilter))
{
var error = string.Format(Properties.Resources.SubscribeFormatter_InvalidTopicFilter, subscription.TopicFilter);
throw new MqttException(error);
}
var topicBytes = MqttProtocol.Encoding.EncodeString(subscription.TopicFilter);
var requestedQosByte = Convert.ToByte(subscription.MaximumQualityOfService);
payload.AddRange(topicBytes);
payload.Add(requestedQosByte);
}
return(payload.ToArray());
}
public async Task ExecuteAsync(string clientId, IPacket input, IMqttChannel <IPacket> channel)
{
if (input.Type != MqttPacketType.Subscribe)
{
return;
}
Subscribe subscribe = input as Subscribe;
ClientSession session = _sessionRepository.Read(clientId);
if (session == null)
{
throw new MqttException(ServerProperties.SessionRepository_ClientSessionNotFound(clientId));
}
List <SubscribeReturnCode> returnCodes = new List <SubscribeReturnCode>();
foreach (Subscription subscription in subscribe.Subscriptions)
{
try
{
if (!_topicEvaluator.IsValidTopicFilter(subscription.TopicFilter))
{
_tracer.Error(ServerProperties.ServerSubscribeFlow_InvalidTopicSubscription(subscription.TopicFilter, clientId));
returnCodes.Add(SubscribeReturnCode.Failure);
continue;
}
ClientSubscription clientSubscription = session
.GetSubscriptions()
.FirstOrDefault(s => s.TopicFilter == subscription.TopicFilter);
if (clientSubscription != null)
{
clientSubscription.MaximumQualityOfService = subscription.MaximumQualityOfService;
}
else
{
clientSubscription = new ClientSubscription
{
ClientId = clientId,
TopicFilter = subscription.TopicFilter,
MaximumQualityOfService = subscription.MaximumQualityOfService
};
session.AddSubscription(clientSubscription);
}
await SendRetainedMessagesAsync(clientSubscription, channel);
MqttQualityOfService supportedQos = _configuration.GetSupportedQos(subscription.MaximumQualityOfService);
SubscribeReturnCode returnCode = supportedQos.ToReturnCode();
returnCodes.Add(returnCode);
}
catch (RepositoryException repoEx)
{
_tracer.Error(repoEx, ServerProperties.ServerSubscribeFlow_ErrorOnSubscription(clientId, subscription.TopicFilter));
returnCodes.Add(SubscribeReturnCode.Failure);
}
}
_sessionRepository.Update(session);
await channel.SendAsync(new SubscribeAck( subscribe.PacketId, returnCodes.ToArray()));
}
public async Task ExecuteAsync(string clientId, IPacket input, IMqttChannel <IPacket> channel)
{
if (input.Type != MqttPacketType.Subscribe)
{
return;
}
var subscribe = input as Subscribe;
var session = sessionRepository.Read(clientId);
if (session == null)
{
throw new MqttException(string.Format(Properties.Resources.SessionRepository_ClientSessionNotFound, clientId));
}
var returnCodes = new List <SubscribeReturnCode> ();
foreach (var subscription in subscribe.Subscriptions)
{
try {
if (!topicEvaluator.IsValidTopicFilter(subscription.TopicFilter))
{
tracer.Error(Server.Properties.Resources.ServerSubscribeFlow_InvalidTopicSubscription, subscription.TopicFilter, clientId);
returnCodes.Add(SubscribeReturnCode.Failure);
continue;
}
var clientSubscription = session
.GetSubscriptions()
.FirstOrDefault(s => s.TopicFilter == subscription.TopicFilter);
if (clientSubscription != null)
{
clientSubscription.MaximumQualityOfService = subscription.MaximumQualityOfService;
}
else
{
Console.WriteLine("Client just connected: " + clientId + " " + subscription.TopicFilter);
clientSubscription = new ClientSubscription {
ClientId = clientId,
TopicFilter = subscription.TopicFilter,
MaximumQualityOfService = subscription.MaximumQualityOfService
};
session.AddSubscription(clientSubscription);
}
await SendRetainedMessagesAsync(clientSubscription, channel)
.ConfigureAwait(continueOnCapturedContext: false);
var supportedQos = configuration.GetSupportedQos(subscription.MaximumQualityOfService);
var returnCode = supportedQos.ToReturnCode();
returnCodes.Add(returnCode);
} catch (RepositoryException repoEx) {
tracer.Error(repoEx, Server.Properties.Resources.ServerSubscribeFlow_ErrorOnSubscription, clientId, subscription.TopicFilter);
returnCodes.Add(SubscribeReturnCode.Failure);
}
}
sessionRepository.Update(session);
await channel.SendAsync(new SubscribeAck (subscribe.PacketId, returnCodes.ToArray()))
.ConfigureAwait(continueOnCapturedContext: false);
}
