public void EndGeneration(int endedGeneration)
{
var current = incomingMessages;
if (current.Generation > endedGeneration)
{
return;
}
lock (this)
{
Log.Message("Inserting message generation " + current.Generation + "->" + (endedGeneration + 1));
//if (!generations.IsEmpty && !generations.ContainsKey(current.Generation - 1))
//throw new IntegrityViolation("Trying to insert generation " + current.Generation + ", but generation " + (current.Generation - 1) + " does not locally exist");
if (generations.TryAdd(current.Generation, current))
{
DB.PutNow(new SerialCCS(new SDS.ID(Simulation.ID.XYZ, current.Generation), current.Export(true)), true);
}
for (int i = current.Generation + 1; i <= endedGeneration; i++)
{
Log.Message("Skipping empty message generation " + i);
var m = new IncomingMessages(i, MessagePack.CompleteBlank);
generations.TryAdd(i, m);
DB.PutNow(new SerialCCS(new SDS.ID(Simulation.ID.XYZ, i), m.Export(true)), true);
}
incomingMessages = new IncomingMessages(endedGeneration + 1);
}
}
public void TrimGenerations(int generationOrOlder)
{
lock (this)
{
LazyList <int> eraseGenerations;
foreach (var p in generations)
{
if (p.Key <= generationOrOlder)
{
eraseGenerations.Add(p.Key);
}
}
foreach (var g in eraseGenerations)
{
IncomingMessages m;
generations.ForceRemove(g, out m);
//if (!m.WasCollected)
//throw new IntegrityViolation("Dumping uncollected messages");
}
if (incomingMessages.Generation <= generationOrOlder)
{
incomingMessages = new IncomingMessages(generationOrOlder + 1);
}
}
}
/// <summary>
/// Асинхронное пакетное чтение множества преременных.
/// </summary>
/// <param name="options">Параметры NiBUS-операции.</param>
/// <param name="target">Адрес устойства.</param>
/// <param name="ids">Список идентификаторов переменных.</param>
/// <returns>
/// Аснихронная задача
/// </returns>
/// <seealso cref="ReadProgressInfo"/>
public async Task ReadManyValuesAsync(NibusOptions options, Address target, params int[] ids)
{
//Contract.Requires(options != null);
//Contract.Requires(options.Progress != null);
//Contract.Requires(target != null);
//Contract.Requires(target.Type == AddressType.Hardware || target.Type == AddressType.Net);
foreach (var splitIds in ids.Split(NmsMessage.NmsMaxDataLength / 3).Select(splitIds => splitIds.ToArray()))
{
NmsMessage lastMessage;
IncomingMessages.TryReceive(null, out lastMessage);
await OutgoingMessages.SendAsync(new NmsReadMany(target, splitIds));
var tasks = from id in splitIds
select GetNmsReadResponseAsync(lastMessage, target, id, options)
.ContinueWith(
task =>
{
var rp = new ReadProgressInfo(target, id, task);
if (Logger.IsTraceEnabled)
{
Logger.Trace("Received id={0}, Exc = {1}", rp.Id, rp.Exception);
}
options.Progress.Report(rp);
});
try
{
await Task.WhenAll(tasks.ToArray());
}
catch (Exception e)
{
Logger.Error(e, "Read failed");
}
}
}
public string Subscribe(string uid, string topicFilter, Action <MqttApplicationMessageReceivedEventArgs> callback)
{
if (topicFilter == null)
{
throw new ArgumentNullException(nameof(topicFilter));
}
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
if (string.IsNullOrEmpty(uid))
{
uid = Guid.NewGuid().ToString("D");
}
lock (Subscribers)
{
Subscribers[uid] = new MqttSubscriber(uid, topicFilter, callback);
}
// Enqueue all retained messages to match the expected MQTT behavior.
// Here we have no client per subscription. So we need to adopt some
// features here manually.
foreach (var retainedMessage in _serverEx.GetRetainedApplicationMessagesAsync().GetAwaiter().GetResult())
{
IncomingMessages.Add(new MqttApplicationMessageReceivedEventArgs(null, retainedMessage));
}
return(uid);
}
public void ProcessIncomingQueue()
{
foreach (RawMessage m in IncomingMessages)
{
ProcessIncomingMessage(m);
}
IncomingMessages.Clear();
}
protected override void Run()
{
Log.Debug("Started sender");
var persistence = new PersistenceManager();
while (true)
{
if (Token.IsCancellationRequested)
{
Log.Debug("Received request to stop");
return;
}
if (IncomingMessages.Count == 0)
{
continue;
}
using (var file = File.Open(Path.Combine(FileInfo.LocalPath, FileInfo.FileName), FileMode.Open))
using (var stream = new BinaryReader(file))
{
while (IncomingMessages.Count > 0)
{
Message mesg;
if (IncomingMessages.TryDequeue(out mesg))
{
if (mesg.MessageId == MessageType.CHUNK_REQUEST)
{
var chunkReq = (ChunkRequest)mesg;
stream.BaseStream.Seek(chunkReq.Size * chunkReq.Index, SeekOrigin.Begin);
var bytes = stream.ReadBytes(chunkReq.Size);
var provider = new RSACryptoServiceProvider();
provider.ImportCspBlob(persistence.ReadContent().KeyInfo);
Log.DebugFormat("Building ChunkReply message for index {0}", chunkReq.Index);
var outMessage = new ChunkReply(Guid.NewGuid(),
chunkReq.ConversationId,
chunkReq.MessageCount + 1,
bytes,
chunkReq.Index,
MessageVerifier.CreateSignature(bytes, provider.ExportParameters(true)));
RaiseSendMessageEvent(outMessage);
}
else if (mesg.MessageId == MessageType.ACKNOWLEDGE)
{
Log.Info("Client acknowledged that it has received all the data");
CancelSource.Cancel();
RaiseEndConversationEvent();
}
}
}
}
}
}
public MessageHistory(int startGeneration, IEnumerable <MessagePack> generations)
{
int g = startGeneration;
foreach (var m in generations)
{
this.generations.ForceAdd(g, new IncomingMessages(g, m));
g++;
}
incomingMessages = new IncomingMessages(g);
}
public void ProcessMessageString(string message, long senderId, bool isglobal)
{
RawMessage rawMessage = new RawMessage();
rawMessage.isGlobal = isglobal;
rawMessage.SenderReceiver = senderId;
rawMessage.Type = (MessageType)BitConverter.ToInt32(Convert.FromBase64String(message.Substring(0, 8)), 0);
rawMessage.Args = Convert.FromBase64String(message.Substring(8));
IncomingMessages.Add(rawMessage);
}
public NetworkMessage <T> GetLatestMessage()
{
NetworkMessage <T> msg;
bool success = IncomingMessages.TryDequeue(out msg);
if (success)
{
return(msg);
}
throw new Exception("No Message Queued! Used HaveIncomingMessage() to check!");
}
/// <summary>
/// Отправляет NMS-сообщение <paramref name="query"/> и ожидает ответа.
/// Асинхронная операция.
/// </summary>
/// <typeparam name="TMessage">Тип сообщения, потомок NmsMessage.</typeparam>
/// <param name="query">Сообщение-запрос.</param>
/// <param name="options">Параметры асинхронной операции.</param>
/// <returns>
/// <see cref="Task{TResult}"/> асинхронная операция - ответное сообщение.
/// </returns>
/// <exception cref="AggregateException">Призошла ошибка в асинхронном коде. См. <see cref="Exception.InnerException"/></exception>
/// <exception cref="TimeoutException">Ошибка по таймауту.</exception>
/// <exception cref="TaskCanceledException">Операция прервана пользователем.</exception>
/// <exception cref="NibusResponseException">Ошибка NiBUS.</exception>
public async Task <TMessage> WaitForNmsResponseAsync <TMessage>(TMessage query, NibusOptions options = null)
where TMessage : NmsMessage
{
//Contract.Requires(!IsDisposed);
//Contract.Requires(
// query.Datagram.Destanation.Type == AddressType.Hardware
// || query.Datagram.Destanation.Type == AddressType.Net);
options = GetDefaultOrClone(options);
// Последнее сообщение в BroadcastBlock всегда остается! Незабываем его фильтровать.
NmsMessage lastMessage;
IncomingMessages.TryReceive(null, out lastMessage);
var wob = new WriteOnceBlock <NmsMessage>(m => m);
using (IncomingMessages.LinkTo(
wob,
m => !ReferenceEquals(lastMessage, m) && m.IsResponse && m.ServiceType == query.ServiceType &&
(query.Id == 0 || m.Id == query.Id) && (query.Datagram.Destanation == Address.Empty || m.Datagram.Source == query.Datagram.Destanation)))
{
for (var i = 0; i < options.Attempts; i++)
{
await OutgoingMessages.SendAsync(query);
try
{
var response =
(TMessage)await wob.ReceiveAsync(options.Timeout, options.Token).ConfigureAwait(false);
if (response.ErrorCode != 0)
{
throw new NibusResponseException(response.ErrorCode);
}
return(response);
}
catch (TimeoutException)
{
Logger.Debug("Timeout {0}", i + 1);
if (i < options.Attempts - 1)
{
continue;
}
throw;
}
}
}
// Эта точка недостижима при attempts > 0!
throw new InvalidOperationException();
}
private async ValueTask <IMessage <T> > FetchSingleMessageFromBroker()
{
// Just being cautious
if (IncomingMessages.Count > 0)
{
_log.Error("The incoming message queue should never be greater than 0 when Queue size is 0");
IncomingMessages.Empty();
}
IMessage <T> message;
try
{
// if cnx is null or if the connection breaks the connectionOpened function will send the flow again
_waitingOnReceiveForZeroQueueSize = true;
if (Connected())
{
IncreaseAvailablePermits(_clientCnx);
}
do
{
message = await IncomingMessages.ReceiveAsync();
_lastDequeuedMessageId = message.MessageId;
var msgCnx = ((Message <T>)message).Cnx();
// synchronized need to prevent race between connectionOpened and the check "msgCnx == cnx()"
// if message received due to an old flow - discard it and wait for the message from the
// latest flow command
if (msgCnx == _clientCnx)
{
_waitingOnReceiveForZeroQueueSize = false;
break;
}
} while(true);
Stats.UpdateNumMsgsReceived(message);
return(message);
}
catch (Exception e)
{
Stats.IncrementNumReceiveFailed();
throw PulsarClientException.Unwrap(e);
}
finally
{
// Finally blocked is invoked in case the block on incomingMessages is interrupted
_waitingOnReceiveForZeroQueueSize = false;
// Clearing the queue in case there was a race with messageReceived
IncomingMessages.Empty();
}
}
protected override void Run()
{
Log.Debug("Started receiver");
var persistence = new PersistenceManager();
for (var i = 0; i < 3; i++)
{
if (Token.IsCancellationRequested)
{
Log.Debug("Received request to stop");
break;
}
while (IncomingMessages.Count > 0)
{
Message mesg;
if (IncomingMessages.TryDequeue(out mesg))
{
if (mesg.MessageId == MessageType.REGISTER_CONTENT_REQUEST)
{
var req = (RegisterContentRequest)mesg;
Log.Info(string.Format("Registering {0} with host {1} and port {2}", req.Name, req.Host, req.Port));
var content = new Content()
{
ContentHash = req.Hash,
ByteSize = req.FileSize,
FileName = req.Name,
Description = req.Description,
Host = req.Host,
Port = req.Port,
LocalPath = ".",
PublicKeyInfo = req.PublicKeyInfo
};
persistence.WriteContent(content, PersistenceManager.StorageType.Local);
var ack = new Acknowledge(Guid.NewGuid(), ConversationId, req.MessageCount + 1, "Accepted register content request");
CancelSource.Cancel();
RaiseSendMessageEvent(ack);
break;
}
}
}
}
RaiseEndConversationEvent();
}
protected override void Run()
{
Log.Debug("Started sender");
var persistence = new PersistenceManager();
// Only try three times
for (var i = 0; i < 3; i++)
{
if (Token.IsCancellationRequested)
{
Log.Debug("Received request to stop");
break;
}
var req = new ContentListRequest(Guid.NewGuid(), ConversationId, 0, Query);
RaiseSendMessageEvent(req);
Thread.Sleep(500);
while (IncomingMessages.Count > 0)
{
Message mesg;
if (IncomingMessages.TryDequeue(out mesg))
{
if (mesg.MessageId == MessageType.CONTENT_LIST_REPLY)
{
var reply = (ContentListReply)mesg;
foreach (var content in reply.ContentList)
{
// TODO This is read the file on every call
persistence.WriteContent(content, PersistenceManager.StorageType.Remote);
}
OnSearchResults?.Invoke(reply.ContentList);
CancelSource.Cancel();
break;
}
}
}
}
RaiseEndConversationEvent();
}
protected override void Run()
{
Log.Debug("Started sender");
var persistence = new PersistenceManager();
while (true)
{
if (Token.IsCancellationRequested)
{
Log.Debug("Received request to stop");
return;
}
// Slow down busy loop
Thread.Sleep(100);
while (IncomingMessages.Count > 0)
{
Message mesg;
if (IncomingMessages.TryDequeue(out mesg))
{
if (mesg.MessageId == MessageType.CONTENT_LIST_REQUEST)
{
var req = (ContentListRequest)mesg;
var availableContent = persistence.ReadContent();
var reply = new ContentListReply(Guid.NewGuid(), ConversationId, req.MessageCount + 1, availableContent.LocalContent);
if (req.ContentQuery != "")
{
// String match the filenames and descriptions for searching content
reply.ContentList = availableContent.LocalContent.Where(content =>
content.Description.ToLower().Contains(req.ContentQuery) ||
content.FileName.ToLower().Contains(req.ContentQuery)).ToList();
}
Log.Info(string.Format("Sending list of {0} content items", reply.ContentList.Count()));
RaiseSendMessageEvent(reply);
RaiseEndConversationEvent();
break;
}
}
}
}
}
protected override void Run()
{
Log.Debug("Started sender");
// Only try three times
for (var i = 0; i < 3; i++)
{
if (Token.IsCancellationRequested)
{
Log.Debug("Received request to stop");
break;
}
RaiseSendMessageEvent(Request);
MessageCount++;
for (int times = 0; times < 10; times++)
{
if (IncomingMessages.Count < 1)
{
Thread.Sleep(250);
}
}
while (IncomingMessages.Count > 0)
{
Message mesg;
if (IncomingMessages.TryDequeue(out mesg))
{
if (mesg.MessageId == MessageType.ACKNOWLEDGE)
{
var ack = (Acknowledge)mesg;
Log.Info(string.Format("Recevied acknowledge with status: {0}", ack.StatusInformation));
CancelSource.Cancel();
break;
}
}
}
}
RaiseEndConversationEvent();
}
public void Process()
{
CancellationToken cancellationToken = new CancellationToken(false);
while (true)
{
Message <CMD> message = IncomingMessages.Take(cancellationToken);
Console.WriteLine(message.Header.Size);
switch (message.Header.Id)
{
case CMD.Chat:
Console.WriteLine("Chat: " + message.Extract <UTF8String>());
break;
default:
Console.WriteLine($"Unknown command: {message.Header.Id}");
break;
}
}
}
private async Task <NmsRead> GetNmsReadResponseAsync(
NmsMessage lastMessage, Address target, int id, NibusOptions options)
{
var wob = new WriteOnceBlock <NmsMessage>(m => m);
using (IncomingMessages.LinkTo(
wob,
m => !ReferenceEquals(lastMessage, m) && m.IsResponse && m.ServiceType == NmsServiceType.Read &&
m.Id == id && (target == Address.Empty || m.Datagram.Source == target)))
{
var response = (NmsRead)await wob.ReceiveAsync(options.Timeout, options.Token).ConfigureAwait(false);
if (response.ErrorCode != 0)
{
throw new NibusResponseException(response.ErrorCode);
}
return(response);
}
}
protected virtual void ReadIncomingPackets()
{
bool canRead = UdpSocket.Available > 0;
if (canRead)
{
IPEndPoint ep = new IPEndPoint(IPAddress.Any, 0);
byte[] data = UdpSocket.Receive(ref ep);
NetworkMessage <T> nm = new NetworkMessage <T>();
nm.Sender = ep;
nm.Packet = new BytePacket <T>(data);
nm.ReceiveTime = DateTime.Now;
IncomingMessages.Enqueue(nm);
PacketsReceived++;
TotalBytesReceived += nm.Packet.Payload.Length;
InternalReceiveCount += nm.Packet.Payload.Length;
LatestReceiveTimestamp = DateTime.Now;
}
}
private void ProcessBuffer(byte[] buffer)
{
if (_currentIncomingMessage == null)
{
_currentIncomingMessage = new mBlockIncomingMessage();
}
foreach (var value in buffer)
{
/* Received message format
* 0xFF - Header Byte 1
* 0x55 - Header Byte 2
* 0xXX - Message index corresponding to request
* 0x0X - Payload Type - 1 byte 2 float 3 short 4 len+string 5 double
* [0xXX....0xXX] Payload matcing size
* 0x0D
* 0x0A
*/
_currentIncomingMessage.AddByte(value);
if (_currentIncomingMessage.EndsWithCRLF())
{
IncomingMessages.Add(_currentIncomingMessage);
if (_currentIncomingMessage.BufferSize > 4)
{
_currentIncomingMessage.MessageSerialNumber = _currentIncomingMessage.Buffer[2];
_logger.NotifyUserInfo("mBlock", $"<<< {_currentIncomingMessage.MessageSerialNumber:X2}. " + _currentIncomingMessage.MessageHexString);
ProcessMessage(_currentIncomingMessage);
}
else
{
_logger.NotifyUserInfo("mBlock", $"<<< XXXXX. " + _currentIncomingMessage.MessageHexString);
}
_currentIncomingMessage = new mBlockIncomingMessage();
}
}
}
private void WebSocketOnMessageReceived(object sender, MessageReceivedEventArgs e)
{
Debug.Print("Websocket message received:\n" + e.Message + "\n");
try
{
var message = JsonConvert.DeserializeObject <SinricMessage>(e.Message);
if (!HmacSignature.ValidateMessageSignature(message, SecretKey))
{
throw new Exception(
"Computed signature for the payload does not match the signature supplied in the message. Message may have been tampered with.");
}
// add to the incoming message queue. caller will retrieve the messages on their own thread
IncomingMessages.Enqueue(message);
}
catch (Exception ex)
{
Debug.Print("Error processing message from Sinric:\n" + ex + "\n");
}
}
private void ProcessBuffer(byte[] buffer)
{
if (_currentIncomingMessage == null)
{
_currentIncomingMessage = new mBlockIncomingMessage();
}
foreach (var value in buffer)
{
/* Received message format
* 0xFF - Header Byte 1
* 0x55 - Header Byte 2
* 0xXX - Message index corresponding to request
* 0x0X - Payload Type - 1 byte 2 float 3 short 4 len+string 5 double
* [0xXX....0xXX] Payload matcing size
* 0x0D
* 0x0A
*/
_currentIncomingMessage.AddByte(value);
if (_currentIncomingMessage.EndsWithCRLF())
{
IncomingMessages.Add(_currentIncomingMessage);
// Debug.WriteLine(String.Format("{0:000000} <<<", (DateTime.Now - _start).TotalMilliseconds) + _currentIncomingMessage.MessageHexString);
_logger.NotifyUserInfo("mBlock", "<<< " + _currentIncomingMessage.MessageHexString);
if (_currentIncomingMessage.BufferSize > 4)
{
_currentIncomingMessage.MessageSerialNumber = _currentIncomingMessage.Buffer[2];
ProcessMessage(_currentIncomingMessage);
}
_currentIncomingMessage = new mBlockIncomingMessage();
}
}
}
public Task <Message> ReceiveMessageAsync(CancellationToken cancellationToken)
{
return(IncomingMessages.ReceiveAsync(cancellationToken));
}
public virtual void HandleMessage(Message mesg)
{
IncomingMessages.Enqueue(mesg);
}
protected override void Run()
{
Log.Debug("Started receiver");
// Only request all packets five times
while (true)
{
if (Token.IsCancellationRequested)
{
Log.Debug("Received request to stop");
break;
}
foreach (var data in NeededData)
{
var chunkReq = new ChunkRequest(Guid.NewGuid(), ConversationId, MessageCount, data, FileInfo.ContentHash, ChunkSize);
RaiseSendMessageEvent(chunkReq);
MessageCount++;
}
Thread.Sleep(250);
while (IncomingMessages.Count > 0)
{
Message mesg;
if (IncomingMessages.TryDequeue(out mesg))
{
if (mesg.MessageId == MessageType.CHUNK_REPLY)
{
var chunkReply = (ChunkReply)mesg;
if (NeededData.Contains(chunkReply.Index))
{
var provider = new RSACryptoServiceProvider();
provider.ImportCspBlob(FileInfo.PublicKeyInfo);
if (MessageVerifier.CheckSignature(chunkReply.ChunkData, chunkReply.Signature, provider.ExportParameters(false)))
{
DataStore[chunkReply.Index] = chunkReply.ChunkData;
NeededData.Remove(chunkReply.Index);
ReceivedData.Add(chunkReply.Index);
if (NeededData.Count == 0)
{
Log.Info(string.Format("Conversation complete; Downloaded {0} packets", DataStore.Count));
var ack = new Acknowledge(Guid.NewGuid(), ConversationId, mesg.MessageCount + 1, "Download complete");
CancelSource.Cancel();
RaiseSendMessageEvent(ack);
break;
}
}
else
{
Log.Warn("Message signature is NOT verfied");
}
}
}
}
}
Thread.Sleep(250);
}
RaiseEndConversationEvent();
}
internal void Server_ApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs e)
{
InboundCounter.Increment();
IncomingMessages.Add(e);
if (string.IsNullOrEmpty(e.ClientId))
{
_logger.LogInformation($"Message: Topic=[{e.ApplicationMessage.Topic }]");
}
else
{
_logger.LogInformation($"Server received {e.ClientId}'s message: Topic=[{e.ApplicationMessage.Topic }],Retain=[{e.ApplicationMessage.Retain}],QualityOfServiceLevel=[{e.ApplicationMessage.QualityOfServiceLevel}]");
if (!lstTopics.ContainsKey(e.ApplicationMessage.Topic))
{
lstTopics.Add(e.ApplicationMessage.Topic, 1);
Task.Run(() => _serverEx.PublishAsync("$SYS/broker/subscriptions/count", lstTopics.Count.ToString()));
}
else
{
lstTopics[e.ApplicationMessage.Topic]++;
}
if (e.ApplicationMessage.Payload != null)
{
received += e.ApplicationMessage.Payload.Length;
}
string topic = e.ApplicationMessage.Topic;
var tpary = topic.Split('/', StringSplitOptions.RemoveEmptyEntries);
if (tpary.Length >= 3 && tpary[0] == "devices" && Devices.ContainsKey(e.ClientId))
{
Device device = JudgeOrCreateNewDevice(tpary, Devices[e.ClientId]);
if (device != null)
{
Dictionary <string, object> keyValues = new Dictionary <string, object>();
if (tpary.Length >= 4)
{
string keyname = tpary.Length >= 5 ? tpary[4] : tpary[3];
if (tpary[3].ToLower() == "xml")
{
try
{
var xml = new System.Xml.XmlDocument();
xml.LoadXml(e.ApplicationMessage.ConvertPayloadToString());
keyValues.Add(keyname, xml);
}
catch (Exception ex)
{
_logger.LogWarning(ex, $"xml data error {topic},{ex.Message}");
}
}
else if (tpary[3].ToLower() == "binary")
{
keyValues.Add(keyname, e.ApplicationMessage.Payload);
}
}
else
{
try
{
keyValues = e.ApplicationMessage.ConvertPayloadToDictionary();
}
catch (Exception ex)
{
_logger.LogWarning(ex, $"ConvertPayloadToDictionary Error {topic},{ex.Message}");
}
}
if (tpary[2] == "telemetry")
{
Task.Run(async() =>
{
try
{
var result = await _dbContext.SaveAsync <TelemetryLatest, TelemetryData>(keyValues, device, DataSide.ClientSide);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Can't upload telemetry to device {device.Name}({device.Id}).the payload is {e.ApplicationMessage.ConvertPayloadToString()}");
}
});
}
else if (tpary[2] == "attributes")
{
if (tpary.Length > 3 && tpary[3] == "request")
{
Task.Run(async() =>
{
await RequestAttributes(tpary, e.ApplicationMessage.ConvertPayloadToDictionary(), device);
});
}
else
{
Task.Run(async() =>
{
try
{
var result = await _dbContext.SaveAsync <AttributeLatest, AttributeData>(keyValues, device, DataSide.ClientSide);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Can't upload attributes to device {device.Name}({device.Id}).the payload is \"{e.ApplicationMessage.ConvertPayloadToString()}\"");
}
});
}
}
}
}
}
}
