public async Task<string[]> GetFieldsByMachines(IList<string> machines)
{
if (machines.Count > 0)
{
var machinesJson = JsonConvert.SerializeObject(machines);
Utils.Query q = new Utils.Query { Type = "GetFieldsByMachines", Field = machinesJson };
var message = new AMQPMessage { Type = AMQPMessageType.Query, Data = JsonConvert.SerializeObject(q), Sender = "management" };
await _amqpconn.SendMessageAsync("direct_message", "database", JsonConvert.SerializeObject(message));
//ricezione query result
string result = await taskCompletionSource.Task;
if (String.IsNullOrEmpty(result))
{
return null;
}
else
{
var fields = JsonConvert.DeserializeObject<List<String>>(result).ToArray();
return fields;
}
}
else
{
return null;
}
}
public static async void GetTelemetryFromDB(string machineId, int period, string field)
{
try
{
var query = new Query();
query.MachineId = machineId;
query.Period = period;
query.Field = field;
var data = JsonConvert.SerializeObject(query);
var request = new AMQPMessage();
request.Sender = _config.Communications.AMQP.Queue;
request.Data = data;
request.Type = AMQPMessageType.Query;
var json = JsonConvert.SerializeObject(request);
//Inizializzo nuovo canale dedicato e riservato al thread corrente
var channel = _amqpconn.CreateChannel();
//Scrivo messaggio query sul canale appena creato
await _amqpconn.SendMessageAsync(_config.Communications.AMQP.Exchange, "database", json, channel);
//Chiudo canale
_amqpconn.CloseChannel(channel);
}
catch (Exception e)
{
log.Error($"Error: {e.Message}");
}
}
public async Task SendMessageAsync(string address, AMQPMessage body, DateTimeOffset?whenToRun = null)
{
if (!_senderLinks.ContainsKey(address))
{
throw new Exception($"Address {address} is not available for AMQP sending");
}
await _senderLinks[address].SendMessageAsync(body, whenToRun).ConfigureAwait(false);
}
public async Task SendMessageAsync(string address, AMQPMessage body, double?timeOffsetSeconds = null)
{
if (!_queueClientHosts.ContainsKey(address))
{
throw new Exception($"Address {address} is not available for AMQP sending");
}
await _queueClientHosts[address].SendMessageAsync(body, timeOffsetSeconds).ConfigureAwait(false);
}
public async Task<string[]> GetMachines()
{
//invio richiesta query a microservizio database
Utils.Query q = new Utils.Query { Type = "GetMachines" };
var message = new AMQPMessage { Type = AMQPMessageType.Query, Data = JsonConvert.SerializeObject(q), Sender = "management" };
await _amqpconn.SendMessageAsync("direct_message", "database", JsonConvert.SerializeObject(message));
//ricezione query result
string result = await taskCompletionSource.Task;
var machines = JsonConvert.DeserializeObject<List<String>>(result).ToArray();
return machines;
}
public async Task SendMessageTrySynchronousFirstAsync(string address, AMQPMessage body, double?timeOffsetSeconds = null)
{
try
{
await ProcessMessageAsync(address, JsonConvert.SerializeObject(body)).ConfigureAwait(false);
}
catch (Exception e)
{
if (!_cancellationToken.IsCancellationRequested)
{
Console.WriteLine($"AMQP exception in sender link for address {address}: {e}");
await SendMessageAsync(address, body, timeOffsetSeconds).ConfigureAwait(false);
}
}
}
/// <summary>
/// Metodo invocato ogni qual volta viene ricevuto un messaggio MQTT
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static async void OnMQTTMessageReceived(object sender, string e)
{
try
{
//Pubblicazione messaggio ricevuto su broker AMQP
var message = new AMQPMessage {
Data = e, Type = AMQPMessageType.Telemetry, Sender = _config.Communications.AMQP.Queue
};
var json = JsonConvert.SerializeObject(message);
await _amqpconn.SendMessageAsync(_config.Communications.AMQP.Exchange, "common", json);
}
catch (Exception ex)
{
_log.ErrorFormat("!ERROR: {0}", ex.ToString());
}
}
public async Task SendMessageAsync(AMQPMessage messageBody, double?timeOffsetSeconds = null)
{
// whenToRun is not supported with RabbitMQ!
SenderLink senderLink;
bool error;
do
{
senderLink = _senderLink;
error = false;
if (CancellationToken.IsCancellationRequested)
{
throw new Exception("AMQP cancellation is requested, can not send message");
}
try
{
if (senderLink == null || senderLink.IsClosed)
{
await InitializeAsync().ConfigureAwait(false);
}
global::Amqp.Message message = new global::Amqp.Message(JsonConvert.SerializeObject(messageBody))
{
Header = new global::Amqp.Framing.Header()
{
Durable = true
}
};
await senderLink.SendAsync(message, TimeSpan.FromSeconds(10)).ConfigureAwait(false);
}
catch (AmqpException e)
{
error = true;
await semaphore.WaitAsync().ConfigureAwait(false);
try
{
if (senderLink == _senderLink)
{
// nobody else handled this before
if (!CancellationToken.IsCancellationRequested)
{
_logger.LogError($"AMQP exception in sender link for address {Address}: {e}");
}
await CloseAsync().ConfigureAwait(false);
}
}
catch (Exception)
{
throw;
}
finally
{
semaphore.Release();
}
if (!CancellationToken.IsCancellationRequested)
{
await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false);
}
}
} while (error);
}
/// <summary>
/// Metodo invocato ogni qual volta viene ricevuto un messaggio AMQP
/// </summary>
/// <param name="sender"></param>
/// <param name="msg"></param>
public async static void OnAMQPMessageReceived(object sender, String msg)
{
try
{
var message = JsonConvert.DeserializeObject <AMQPMessage>(msg);
switch (message.Type)
{
//Ricezione telemetrie istantanee da broker AMQP
case AMQPMessageType.Telemetry:
//scrittura su database InfluxDB
await _dbconnection.WriteData(message.Data);
break;
//Ricezione richiesta di query da parte del microservizio DATABASE
case AMQPMessageType.Query:
var query = JsonConvert.DeserializeObject <Query>(message.Data);
int period = query.Period;
var machineId = query.MachineId;
var req_sender = message.Sender;
var field = query.Field;
var type = query.Type;
var result = "";
switch (type)
{
case "GetMachines":
result = await _dbconnection.GetMachines();
break;
case "GetFieldsByMachines":
var machines = JsonConvert.DeserializeObject <List <String> >(field);
result = await _dbconnection.GetFieldsByMachine(machines);
break;
default:
result = await _dbconnection.ReadData(machineId, field, period);
break;
}
var body = new AMQPMessage {
Type = AMQPMessageType.QueryResult, Data = result, Sender = _config.Communications.AMQP.Queue
};
var json = JsonConvert.SerializeObject(body);
//invio risposta
await _amqpconn.SendMessageAsync(_config.Communications.AMQP.Exchange, req_sender, json);
break;
}
Console.WriteLine("{0} - {1}: ", message.Type.ToString(), message.Data);
}
catch (Exception e)
{
log.ErrorFormat("!ERROR: {0}", e.ToString());
}
}
public async Task SendMessageAsync(AMQPMessage messageBody, double?timeOffsetSeconds = null)
{
QueueClient queueClient;
bool error;
do
{
queueClient = _queueClient;
error = false;
if (CancellationToken.IsCancellationRequested)
{
throw new Exception("AMQP cancellation is requested, can not send message");
}
try
{
if (queueClient == null || queueClient.IsClosedOrClosing)
{
await InitializeAsync().ConfigureAwait(false);
}
var message = new Microsoft.Azure.ServiceBus.Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageBody)))
{
ContentType = "application/json",
MessageId = Guid.NewGuid().ToString()
};
if (timeOffsetSeconds == null)
{
await queueClient.SendAsync(message).ConfigureAwait(false);
}
else
{
await queueClient.ScheduleMessageAsync(message, DateTimeOffset.UtcNow.AddSeconds((double)timeOffsetSeconds)).ConfigureAwait(false);
}
}
catch (Exception e)
{
error = true;
await semaphore.WaitAsync().ConfigureAwait(false);
try {
if (queueClient == _queueClient)
{
// nobody else handled this before
if (!CancellationToken.IsCancellationRequested)
{
Console.WriteLine($"AMQP exception in sender link for address {Address}: {e}");
}
await CloseAsync().ConfigureAwait(false);
}
}
catch (Exception e2)
{
throw e2;
}
finally
{
semaphore.Release();
}
if (!CancellationToken.IsCancellationRequested)
{
await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false);
}
}
} while (error);
}
