private void Consumer_Received(object sender, BasicDeliverEventArgs ea)
{
try
{
_semaphore.Wait();
LocationWriteDataQueue message = _objectDataConverter.JsonToObject <LocationWriteDataQueue>(Encoding.UTF8.GetString(ea.Body));
MessageReceived?.Invoke(this, message);
Task.Run(() =>
{
try
{
var task = _locationInfoService.FileWritingOperation(message);
task.Wait();
var result = task.Result;
MessageProcessed?.Invoke(this, result);
}
catch (Exception ex)
{
//log
//throw new Exception(ex.InnerException.Message.ToString());
}
finally
{
_channel.BasicAck(ea.DeliveryTag, false);
_semaphore.Release();
}
});
}
catch (Exception ex)
{
//loglama
//throw new Exception(ex.InnerException.Message.ToString());
}
}
private void OnMessageProcessed(Session session)
{
MessageProcessed?.Invoke(this, new MessageProcessedEventArgs()
{
Session = session
});
}
private void OnMessageProcessed(Session session, Response response)
{
MessageProcessed?.Invoke(this, new MessageProcessedEventArgs()
{
Session = session, Parameter = response
});
}
private void Consumer_Received(object sender, BasicDeliverEventArgs ea)
{
try
{
_semaphore.Wait();
MailMessageData message = _objectConvertFormat.JsonToObject <MailMessageData>(Encoding.UTF8.GetString(ea.Body));
MessageReceived?.Invoke(this, message);
// E-Posta akışını başlatma yeri
Task.Run(() =>
{
try
{
var task = _mailSender.SendMailAsync(message);
task.Wait();
var result = task.Result;
MessageProcessed?.Invoke(this, result);
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message.ToString());
}
finally
{
// Teslimat Onayı
_channel.BasicAck(ea.DeliveryTag, false);
// akışı - thread'i serbest bırakıyoruz ek thread alabiliriz.
_semaphore.Release();
}
});
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message.ToString());
}
}
public void FireMessageProcessedEvent()
{
if (MessageProcessed != null)
{
MessageProcessed.Invoke(this);
}
}
public async Task HandleCommand(Payload cmdPayload, PowerPilotCommon.Models.PostgreSQL.Connection connection)
{
foreach (Payload.Types.Metric metric in cmdPayload.Metrics)
{
if (metric.Name == $"{DeviceCommands.TYPE}/{DeviceCommands.REBIRTH}")
{
var downlink = await BuildDBIRTH(connection);
MessageProcessed?.Invoke(this, new MQTTMessageArgs(string.Format(_publishTopic, SparkPlugMessageTypes.DBIRTH, connection.DeviceEUI), downlink.ToByteArray()));
}
}
}
// Обработка приходящих сообщений
private void Vk_MessageReceived(object sender, MessageEventArgs e)
{
// Добавление в Users, если отсутствует
if (!Users.Contains(e.Message.Id))
{
Task.Delay(300).Wait();
var name = vk.GetUsername(e.Message.Id);
if (name != null)
{
Users.AddUser(e.Message.Id, name, null);
}
}
// Вызов события о новом сообщении
MessageReceived?.Invoke(this, e);
// Пинаем каждый модуль чтоб он обработал сообщения
for (int i = 0; i < Extensions.Length; i++)
{
var extension = Extensions[i];
// Скипаем выключенные модули
if (!extension.Enabled)
{
continue;
}
// Передаём модулям сообщения для обработки
MessageProcessing?.Invoke(this, new MessageProcessedEventArgs(extension));
var res = extension.ProcessMessage(e.Message.Id, e.Message.Text);
// Логирование и остановка обработки
if (res == ProcessResult.Processed)
{
MessageProcessed?.Invoke(this, new MessageProcessedEventArgs(extension));
if (extension.StopAfterProcessed)
{
ExtensionStopProcessing?.Invoke(this, new MessageProcessedEventArgs(extension));
return;
}
}
else if (res == ProcessResult.Skipped)
{
MessageSkipped?.Invoke(this, new MessageProcessedEventArgs(extension));
}
}
}
public void OnMQTTClientConnected(object sender, EventArgs e)
{
if (!nbirth_sent)
{
Payload payload = new Payload()
{
Seq = GetSeq(),
Timestamp = (ulong)DateTimeOffset.Now.ToUnixTimeSeconds()
};
//namespace/group_id/message_type/edge_node_id
//$"spBv1.0/DTX/{SparkPlugMessageTypes.NBIRTH}/PowerPilotCS";
var topic = string.Format(_publishTopic, SparkPlugMessageTypes.NBIRTH, "").TrimEnd('/');
MessageProcessed?.Invoke(this, new MQTTMessageArgs(topic, payload.ToByteArray()));
nbirth_sent = true;
}
}
// Цикл обработки сообщений
private void MessageProcessingLoop()
{
while (scriptProcessor.State != Interpreter.ExecutionState.Finished)
{
var messageToProcess = messages.Take();
string eventName = GetScriptEventNameForMessage(messageToProcess);
// Подготовить данные для обработки скриптом
if (eventName != null)
{
var player = session.GetPlayerById(messageToProcess.SenderId);
var eventData = messageToProcess.ToDictionary();
if (player != null)
{
// Если задан ID игрока - передать его место за столом
eventData.Add(PlayerIndexField, player.SeatIndex);
}
object results = null;
try
{
results = scriptProcessor.RaiseEvent(eventName, eventData);
}
catch (Exception e)
{
var exceptionArgs = new ScriptErrorEventArgs(e);
ScriptErrorOccured?.Invoke(this, exceptionArgs);
}
if (results != null && results is object[])
{
// Обработка результатов
var resultsList = results as object[];
var changes = resultsTranslator.Translate(resultsList);
// Вызвать обработчики события
var eventArgs = new MessageProcessedEventArgs(changes);
MessageProcessed?.Invoke(this, eventArgs);
}
}
}
}
private async Task ProcessMessages(CancellationToken cancellationToken)
{
foreach (var message in _messageQueue.GetConsumingEnumerable(cancellationToken))
{
_logger.LogDebug(FormattableString.Invariant($"Processing message..."));
if (_configuration.TryGetMapping(message.Address, out var mapping))
{
try
{
await _restClient.InvokeService(mapping, cancellationToken);
}
catch (Exception ex) when(!cancellationToken.IsCancellationRequested)
{
_logger.LogError(FormattableString.Invariant($"Error invoking REST service for mapping. Key='{mapping.Key}'{Environment.NewLine}{ex}"));
}
}
MessageProcessed?.Invoke(this, EventArgs.Empty);
}
}
private void Consumer_Received(object sender, BasicDeliverEventArgs ea)
{
try
{
_semaphore.Wait();
LocationReadDataQueue message = _objectDataConverter.JsonToObject <LocationReadDataQueue>(Encoding.UTF8.GetString(ea.Body));
MessageReceived?.Invoke(this, message);
Task.Run(() =>
{
try
{
var task = _locationInfoService.GetLocationsDistanceAsync(message);
task.Wait();
var result = task.Result;
var insertedTask = _locationInfoService.QueueDatabaseCreatedAfterSendFileProcess(result);
insertedTask.Wait();
MessageProcessed?.Invoke(this, result);
}
catch (Exception ex)
{
//throw new Exception(ex.InnerException.Message.ToString());
}
finally
{
_channel.BasicAck(ea.DeliveryTag, false);
_semaphore.Release();
}
});
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message.ToString());
}
}
/// <summary>
/// Обработка события получения сообщений.
/// Разблокировка метода (для дальнейшего получения сообщений из брокера) происходит
/// по завершению обработки сообщения и высвобождению вакантного потока.
/// </summary>
private void Consumer_Received(object sender, BasicDeliverEventArgs ea)
{
/// Ожидание вакантного потока для продолжения выполнения метода
_semaphore.Wait();
var message = ParseMailMessageData(ea.Body);
MessageReceived?.Invoke(this, message);
/// Запуск потока отправки письма
Task.Run(() => {
try {
var task = _mailSender.SendMailAsync(message);
task.Wait();
var result = task.Result;
MessageProcessed?.Invoke(this, result);
} finally {
/// Подтверждение доставки
_channel.BasicAck(ea.DeliveryTag, false);
/// Высвобождение потока
_semaphore.Release();
}
});
}
/// <summary>
/// Raise a <see cref="MessageProcessed"/> event
/// </summary>
/// <param name="e">Send the <see cref="FeedMessage"/> originally received</param>
protected void RaiseOnMessageProcessedEvent(FeedMessageReceivedEventArgs e)
{
Guard.Argument(e, nameof(e)).NotNull();
MessageProcessed?.Invoke(this, e);
}
/// <inheritdoc cref="IMailClient.SendAsync(IMessageBuilder, IDataRecord, IEnumerable{IMessageMutator}, CancellationToken)"/>
protected virtual async Task <(MimeMessage?Message, bool Stop)> SendAsyncImpl(IMessageBuilder messageBuilder, IDataRecord record, IEnumerable <IMessageMutator> messageMutators, IFormatProvider formatProvider, int index, int count, CancellationToken cancellationToken)
{
IMessageBuilder message = messageBuilder.Clone();
FormatMessage(message, record, formatProvider);
foreach (IMessageMutator mutator in messageMutators)
{
try
{
message = mutator.Mutate(message, record);
}
catch (Exception e)
{
MessageMutationErrorEventArgs errorArgs = new MessageMutationErrorEventArgs(message, mutator, e);
MessageMutationError?.Invoke(this, errorArgs);
if (errorArgs.Stop)
{
return(null, true);
}
else if (errorArgs.Skip)
{
MessageProcessed?.Invoke(this, new MessageProcessedEventArgs(message.ToMessage(), index, count, ProcessedType.Skipped));
return(null, false);
}
else if (errorArgs.SkipMutation)
{
continue;
}
throw;
}
}
BeforeMessageSentEventArgs beforeArgs = new BeforeMessageSentEventArgs(message);
BeforeMessageSent?.Invoke(this, beforeArgs);
if (beforeArgs.Stop)
{
return(null, true);
}
else if (beforeArgs.Skip)
{
MessageProcessed?.Invoke(this, new MessageProcessedEventArgs(message.ToMessage(), index, count, ProcessedType.Skipped));
return(null, false);
}
MimeMessage result = message.ToMessage();
int attempt = 0;
while (true)
{
try
{
ITransferProgress transferProgress = new TransferProgress((bytesTransferred, totalSize) =>
MessageTransferProgress?.Invoke(this, new MessageTransferProgressEventArgs(result, bytesTransferred, totalSize)));
await Client.SendAsync(result, cancellationToken, progress : transferProgress).ConfigureAwait(false);
MessageSent?.Invoke(this, new MessageSentEventArgs(result));
MessageProcessed?.Invoke(this, new MessageProcessedEventArgs(result, index, count, ProcessedType.Sent));
return(result, false);
}
catch (Exception e)
{
MessageTransferErrorEventArgs errorArgs = new MessageTransferErrorEventArgs(result, e, ++attempt);
MessageTransferError?.Invoke(this, errorArgs);
if (errorArgs.Stop)
{
return(null, true);
}
else if (errorArgs.Skip)
{
MessageProcessed?.Invoke(this, new MessageProcessedEventArgs(result, index, count, ProcessedType.Skipped));
return(null, false);
}
else if (errorArgs.Retry)
{
continue;
}
throw;
}
}
}
/// <summary>
/// Raise a <see cref="MessageProcessed"/> event
/// </summary>
/// <param name="e">Send the <see cref="FeedMessage"/> originally received</param>
protected void RaiseOnMessageProcessedEvent(FeedMessageReceivedEventArgs e)
{
Contract.Requires(e != null);
MessageProcessed?.Invoke(this, e);
}
public async void ProcessMessage(object sender, MQTTMessageArgs args)
{
try
{
string[] parts = args.Topic.Split("/");
string deviceEUI = null;
string messageType = null;
if (parts[0] == "application")
{
// application/powerpilot/uplink/{type}/{deviceEUI}
messageType = parts[3];
deviceEUI = parts[4];
}
else if (parts[0] == "spBv1.0")
{
// spBv1.0/DTX/{0}/PowerPilotCS/{1}
messageType = parts[2];
deviceEUI = parts[4];
}
if (deviceEUI == null)
{
_loggerClient.LogError($"Could not get device eui from {args.Topic}", "ProcessMessage", Pplogger.ErrorMessage.Types.Severity.Fatal);
return;
}
// check if this device exists in our system
var connection = await _dataService.GetConnection(deviceEUI);
if (connection == null)
{
return;
}
Payload payload = new Payload()
{
Seq = GetSeq(),
Timestamp = (ulong)DataServiceClient.ConvertToTimestamp(DateTime.Now)
};
// check if we have this deviceEUI already, if not then send DBIRTH
// use lock to avoid concurrent adds
bool added = false;
lock (dbirthLock)
{
if (!deviceEUIs.Contains(deviceEUI))
{
deviceEUIs.Add(deviceEUI);
added = true;
}
}
if (added)
{
var dbirthPayload = await BuildDBIRTH(connection);
MessageProcessed?.Invoke(this, new MQTTMessageArgs(string.Format(_publishTopic, SparkPlugMessageTypes.DBIRTH, connection.DeviceEUI), dbirthPayload.ToByteArray()));
// return;
}
// var topic = $"spBv1.0/DTX/{SparkPlugMessageTypes.DDATA}/PowerPilotCS/{deviceEUI}";
switch (messageType)
{
// sparkplug commands
case SparkPlugMessageTypes.DCMD:
var cmd = Payload.Parser.ParseFrom(args.Payload);
await HandleCommand(cmd, connection);
break;
// powerpilot messages
case TopicNames.ENERGY:
var energy = Ppuplink.EnergyMessage.Parser.ParseFrom(args.Payload);
var energyPayload = AddEnergyMetrics(energy, payload);
MessageProcessed?.Invoke(this, new MQTTMessageArgs(string.Format(_publishTopic, SparkPlugMessageTypes.DDATA, deviceEUI), energyPayload.ToByteArray()));
break;
case TopicNames.PQ:
var pq = Ppuplink.PQMessage.Parser.ParseFrom(args.Payload);
var pqPayload = AddPQMetrics(pq, payload, connection);
MessageProcessed?.Invoke(this, new MQTTMessageArgs(string.Format(_publishTopic, SparkPlugMessageTypes.DDATA, deviceEUI), pqPayload.ToByteArray()));
break;
case TopicNames.INST:
var inst = Ppuplink.InstMessage.Parser.ParseFrom(args.Payload);
// not interested yet
break;
case TopicNames.ALARM:
var alarm = Ppuplink.AlarmMessage.Parser.ParseFrom(args.Payload);
var alarmPayload = AddAlarmMetrics(alarm, payload, connection);
MessageProcessed?.Invoke(this, new MQTTMessageArgs(string.Format(_publishTopic, SparkPlugMessageTypes.DDATA, deviceEUI), alarmPayload.ToByteArray()));
//if power fail also need DDEATH
if (alarm.Alarmtype == "powerfailalarm")
{
var ddeathPayload = BuildDDEATH(alarm);
var ddeath_topic = string.Format(_publishTopic, SparkPlugMessageTypes.DDEATH, deviceEUI); // $"spBv1.0/DTX/{SparkPlugMessageTypes.DDEATH}/PowerPilotCS/{deviceEUI}";
MessageProcessed?.Invoke(this, new MQTTMessageArgs(ddeath_topic, ddeathPayload.ToByteArray()));
}
//if normal voltage then also need DBIRTH
else if (alarm.Alarmtype == "normalvoltage")
{
var dbirthPayload = await BuildDBIRTH(connection);
MessageProcessed?.Invoke(this, new MQTTMessageArgs(string.Format(_publishTopic, SparkPlugMessageTypes.DBIRTH, connection.DeviceEUI), dbirthPayload.ToByteArray()));
}
break;
case TopicNames.UPLINK:
var uplink = Ppuplink.UplinkMessage.Parser.ParseFrom(args.Payload);
var uplinkPayload = AddUplinkMetrics(uplink, payload);
MessageProcessed?.Invoke(this, new MQTTMessageArgs(string.Format(_publishTopic, SparkPlugMessageTypes.DDATA, deviceEUI), uplinkPayload.ToByteArray()));
break;
case TopicNames.VOLTAGE_STATS:
var vs = Ppuplink.VoltageStatsMessage.Parser.ParseFrom(args.Payload);
var vsPayload = AddVoltageStatsMetrics(vs, payload, connection);
MessageProcessed?.Invoke(this, new MQTTMessageArgs(string.Format(_publishTopic, SparkPlugMessageTypes.DDATA, deviceEUI), vsPayload.ToByteArray()));
break;
default:
_loggerClient.LogMessage($"Not processing type {messageType}");
break;
}
}
catch (Exception ex)
{
_loggerClient.LogError($"Exception while processing Message: {ex.Message}", "ProcessMessage", Pplogger.ErrorMessage.Types.Severity.Fatal);
if (ex.StackTrace != null)
{
_loggerClient.LogMessage(ex.StackTrace);
}
return;
}
}