/// <summary>
/// MQTT subscribe to a topic. Remember, these subscriptionns are ephemeral.
/// </summary>
/// <param name="topicUriString"></param>
/// <param name="qos"></param>
/// <param name="action"></param>
/// <returns></returns>
public async Task SubscribeAsync(string topicUriString, QualityOfServiceLevelType qos, Action <string, string, byte[]> action)
{
try
{
Dictionary <string, QualityOfServiceLevelType> dict = new Dictionary <string, QualityOfServiceLevelType>();
dict.Add(topicUriString, qos);
dispatcher.Register(topicUriString, action);
SubscribeMessage msg = new SubscribeMessage(session.NewId(), dict);
//if (channel.RequireBlocking)
//{
// channel.SendAsync(msg.Encode()).GetAwaiter();
// //Task t = channel.SendAsync(msg.Encode());
// //Task.WaitAll(t);
//}
//else
//{
await channel.SendAsync(msg.Encode());
//}
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(channel.Id, ex));
}
}
/// <summary>
/// Unsubscribe from an ephemeral subscription.
/// </summary>
/// <param name="topics"></param>
/// <returns></returns>
public async Task UnsubscribeAsync(IEnumerable <string> topics)
{
try
{
UnsubscribeMessage msg = new UnsubscribeMessage(session.NewId(), topics);
//if (channel.RequireBlocking)
//{
// Task t = channel.SendAsync(msg.Encode());
// Task.WaitAll(t);
//}
//else
//{
await channel.SendAsync(msg.Encode());
//}
foreach (var topic in topics)
{
dispatcher.Unregister(topic);
}
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(channel.Id, ex));
}
}
/// <summary>
/// MQTT subscribe to a topic. Remember, these subscriptions are ephemeral.
/// </summary>
/// <param name="subscriptions"></param>
/// <returns></returns>
public async Task SubscribeAsync(Tuple <string, QualityOfServiceLevelType, Action <string, string, byte[]> >[] subscriptions)
{
try
{
Dictionary <string, QualityOfServiceLevelType> dict = new Dictionary <string, QualityOfServiceLevelType>();
foreach (var tuple in subscriptions)
{
dict.Add(tuple.Item1, tuple.Item2);
dispatcher.Register(tuple.Item1, tuple.Item3);
}
SubscribeMessage msg = new SubscribeMessage(session.NewId(), dict);
//if (channel.RequireBlocking)
//{
// channel.SendAsync(msg.Encode()).GetAwaiter();
// //Task t = channel.SendAsync(msg.Encode());
// //Task.WaitAll(t);
//}
//else
//{
await channel.SendAsync(msg.Encode());
//}
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(channel.Id, ex));
}
}
public async Task <ConnectAckCode> ConnectAsync(string clientId, string username, string password,
int keepaliveSeconds)
{
code = null;
ConnectMessage msg = new ConnectMessage(clientId, username, password, keepaliveSeconds, true);
if (!Channel.IsConnected)
{
try
{
await Channel.OpenAsync();
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(Channel.Id, ex));
return(ConnectAckCode.ServerUnavailable);
}
try
{
Receive(Channel);
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(Channel.Id, ex));
return(ConnectAckCode.ServerUnavailable);
}
}
try
{
await Channel.SendAsync(msg.Encode());
DateTime expiry = DateTime.UtcNow.AddMilliseconds(timeoutMilliseconds);
while (!code.HasValue)
{
await Task.Delay(10);
if (DateTime.UtcNow > expiry)
{
throw new TimeoutException("MQTT connection timed out.");
}
}
return(code.Value);
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(Channel.Id, ex));
return(ConnectAckCode.ServerUnavailable);
}
}
/// <summary>
/// MQTT publish to a topic.
/// </summary>
/// <param name="qos"></param>
/// <param name="topicUriString"></param>
/// <param name="contentType"></param>
/// <param name="data"></param>
/// <param name="indexes"></param>
/// <param name="messageId"></param>
/// <returns></returns>
public async Task PublishAsync(QualityOfServiceLevelType qos, string topicUriString, string contentType, byte[] data, string cacheKey = null, IEnumerable <KeyValuePair <string, string> > indexes = null, string messageId = null)
{
try
{
string indexString = GetIndexString(indexes);
UriBuilder builder = new UriBuilder(topicUriString);
string queryString = messageId == null?String.Format("{0}={1}", SkunkLab.Protocols.Utilities.QueryStringConstants.CONTENT_TYPE, contentType) : String.Format("{0}={1}&{2}={3}", QueryStringConstants.CONTENT_TYPE, contentType, QueryStringConstants.MESSAGE_ID, messageId);
if (!string.IsNullOrEmpty(cacheKey))
{
queryString = queryString + String.Format("&{0}={1}", QueryStringConstants.CACHE_KEY, cacheKey);
}
if (!string.IsNullOrEmpty(indexString))
{
queryString = queryString + "&" + indexString;
}
builder.Query = queryString;
PublishMessage msg = new PublishMessage(false, qos, false, 0, builder.ToString().ToLowerInvariant(), data);
if (qos != QualityOfServiceLevelType.AtMostOnce)
{
msg.MessageId = session.NewId();
session.Quarantine(msg, DirectionType.Out);
}
queue.Enqueue(msg.Encode());
while (queue.Count > 0)
{
byte[] message = queue.Dequeue();
//if (channel.RequireBlocking)
//{
// //Task t = channel.SendAsync(message);
// //Task.WaitAll(t);
//}
//else
//{
await channel.SendAsync(message);
//}
}
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(channel.Id, ex));
}
}
/// <summary>
/// MQTT subscribe to a topic. Remember, these subscriptionns are ephemeral.
/// </summary>
/// <param name="topicUriString"></param>
/// <param name="qos"></param>
/// <param name="action"></param>
/// <returns></returns>
public async Task SubscribeAsync(string topicUriString, QualityOfServiceLevelType qos, Action <string, string, byte[]> action)
{
try
{
Dictionary <string, QualityOfServiceLevelType> dict = new Dictionary <string, QualityOfServiceLevelType>();
dict.Add(topicUriString.ToLowerInvariant(), qos);
dispatcher.Register(topicUriString.ToLowerInvariant(), action);
SubscribeMessage msg = new SubscribeMessage(session.NewId(), dict);
await channel.SendAsync(msg.Encode());
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(channel.Id, ex));
}
}
public async Task UnsubscribeAsync(string topic)
{
try
{
UnsubscribeMessage msg = new UnsubscribeMessage(session.NewId(), new[] { topic });
await Channel.SendAsync(msg.Encode());
dispatcher.Unregister(topic);
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(Channel.Id, ex));
}
}
public async Task UnsubscribeAsync(IEnumerable <string> topics)
{
try
{
UnsubscribeMessage msg = new UnsubscribeMessage(session.NewId(), topics);
await Channel.SendAsync(msg.Encode());
foreach (string topic in topics)
{
dispatcher.Unregister(topic);
}
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(Channel.Id, ex));
}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs args)
{
MqttMessage msg = MqttMessage.DecodeMessage(args.Message);
MqttMessageHandler handler = MqttMessageHandler.Create(session, msg, dispatcher);
try
{
MqttMessage message = handler.ProcessAsync().GetAwaiter().GetResult();
if (message != null)
{
channel.SendAsync(message.Encode()).GetAwaiter();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Trace.TraceError(ex.Message);
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(channel.Id, ex));
}
//Task task = Task.Factory.StartNew(async () =>
//{
// try
// {
// MqttMessage message = await handler.ProcessAsync();
// if (message != null)
// {
// await channel.SendAsync(message.Encode());
// }
// }
// catch(Exception ex)
// {
// Console.WriteLine(ex.Message);
// Trace.TraceError(ex.Message);
// }
//});
//Task.WaitAll(task);
//if (task.Exception != null)
//{
// OnChannelError?.Invoke(this, new ChannelErrorEventArgs(channel.Id, task.Exception.InnerException));
//}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs args)
{
MqttMessage msg = MqttMessage.DecodeMessage(args.Message);
MqttMessageHandler handler = MqttMessageHandler.Create(session, msg, dispatcher);
try
{
MqttMessage message = handler.ProcessAsync().GetAwaiter().GetResult();
if (message != null)
{
Channel.SendAsync(message.Encode()).GetAwaiter();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Trace.TraceError(ex.Message);
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(Channel.Id, ex));
}
}
public async Task SubscribeAsync(
Tuple <string, QualityOfServiceLevelType, Action <string, string, byte[]> >[] subscriptions)
{
try
{
Dictionary <string, QualityOfServiceLevelType>
dict = new Dictionary <string, QualityOfServiceLevelType>();
foreach (var tuple in subscriptions)
{
dict.Add(tuple.Item1, tuple.Item2);
dispatcher.Register(tuple.Item1, tuple.Item3);
}
SubscribeMessage msg = new SubscribeMessage(session.NewId(), dict);
await Channel.SendAsync(msg.Encode());
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(Channel.Id, ex));
}
}
/// <summary>
/// Unsubscribe from an ephemeral subscription.
/// </summary>
/// <param name="topic"></param>
/// <returns></returns>
public async Task UnsubscribeAsync(string topic)
{
try
{
UnsubscribeMessage msg = new UnsubscribeMessage(session.NewId(), new string[] { topic });
//if (channel.RequireBlocking)
//{
// Task t = channel.SendAsync(msg.Encode());
// Task.WaitAll(t);
//}
//else
//{
await channel.SendAsync(msg.Encode());
//}
dispatcher.Unregister(topic);
}
catch (Exception ex)
{
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(channel.Id, ex));
}
}
private void Channel_OnError(object sender, ChannelErrorEventArgs args)
{
OnChannelError?.Invoke(this, args);
}