public long Store(IRawMessage message, IQueueSettings queueSettings)
{
var retry = new MessageDocument
{
ApplicationId = queueSettings.ApplicationId
};
headerParser.AddHeaderInformation(message, retry);
retry.Body = message.Body;
var expiry = DateTime.UtcNow.AddHours(retry.IsError ? queueSettings.ErrorDocumentExpirationInHours : queueSettings.DocumentExpirationInHours);
long originalId = -1;
long.TryParse(message.Headers[Headers.Retry], out originalId);
long documentIdToReturn = -1;
//deal with rare transients that happen under load
var policy = Policy.Handle <Exception>().WaitAndRetry(new TimeSpan[] { TimeSpan.FromMilliseconds(5), TimeSpan.FromMilliseconds(10) }, (exception, retryDelay, context) =>
{
logger.ErrorException($"Retrying storage of message document with delay {retryDelay} after exception", exception);
});
policy.Execute(() =>
{
documentIdToReturn = SaveDocument(queueSettings, originalId, retry, expiry);
});
return(documentIdToReturn);
}
public void TempSave(string seller, List <ILot> lots, IQueueSettings queueSettings)
{
if (!Directory.Exists($"{queueSettings.SaveTempFolderPath}"))
{
DirectoryInfo folder = Directory.CreateDirectory($"{queueSettings.SaveTempFolderPath}");
folder.Attributes = FileAttributes.Directory | FileAttributes.Hidden;
}
string filePath = $"{queueSettings.SaveTempFolderPath}\\{queueSettings.TempFilePrefix} {seller}.csv";
string[] data = new string[lots.Count];
for (int i = 0; i < data.Length; i++)
{
data[i] = lots[i].GetData();
}
try
{
File.WriteAllLines(filePath, data, Encoding.UTF8);
}
catch (Exception e)
{
Console.WriteLine($"Ошибка при сохранении временного файла {filePath}.\r\nError: {e.Message}");
}
}
public RmqBus(IQueueSettings settings, ISerializer serializer, IMemoryStreamPool memoryStreamPool)
{
Settings = settings;
Serializer = serializer;
MemoryStreamPool = memoryStreamPool;
Connections = new ConnectionPool();
Subscriptions = new RmqSubscriptions(this);
}
internal QueuePoller(Guid key, IQueueSettings queueSettings)
{
Verify.RequireNotNull(key, "key");
Verify.RequireNotNull(queueSettings, "queueSettings");
QueueSettings = queueSettings;
Key = key;
}
public void CreateQueueExchangeBinding(IQueueSettings queueSettings)
{
_queueChannelManager
.GetChannel()
.QueueBind(queueSettings.QueueName,
queueSettings.ExchangeName,
queueSettings.RoutingKey,
null);
}
public IntegrationEventQueue(IQueueChannelManager responseQueueChannelManager,
IQueueSettingsResolver queueSettingsResolver,
IQueueFactory responseQueueFactory,
ILoggerFactory loggerFactory)
{
_logger = loggerFactory.GetLogger <IntegrationEventQueue>();
_responseQueueChannelManager = responseQueueChannelManager;
_settings = queueSettingsResolver.GetSettings(nameof(IntegrationEventQueue));
responseQueueFactory.SetupQueue(_settings);
}
public void CreateExchange(IQueueSettings queueSettings)
{
_queueChannelManager
.GetChannel()
.ExchangeDeclare(exchange: queueSettings.ExchangeName,
type: queueSettings.ExchangeType,
durable: queueSettings.IsQueueDurable,
autoDelete: queueSettings.DeleteQueueIfNoConsumers,
arguments: null);
}
public TransactionProcessorIntegrationEventQueue(IQueueChannelManager responseQueueChannelManager,
IQueueSettingsResolver queueSettingsResolver,
IQueueFactory responseQueueFactory,
ILoggerFactory loggerFactory)
{
_logger = loggerFactory.GetLogger <IntegrationEventQueue>();
_responseQueueChannelManager = responseQueueChannelManager;
_settings = queueSettingsResolver.GetSettings(nameof(IntegrationEventQueue));
responseQueueFactory.CreateExchange(_settings);
}
private void SaveDocument(IQueueSettings queueSettings, MessageDocument document, DateTime expiry)
{
using (var session = documentStore.OpenSessionForDefaultTenant())
{
session.Store(document);
session.Advanced.GetMetadataFor(document)["Raven-Expiration-Date"] = new RavenJValue(expiry);
session.SaveChanges();
logger.Trace("Saved document for message with id {0} from {1}", document.Id, queueSettings.LogInfo);
}
}
public void CreateDeadLetterQueue(IQueueSettings queueSettings)
{
_queueChannelManager
.GetChannel()
.QueueDeclare(queue: queueSettings.DeadLetterQueueSettings.QueueName,
durable: queueSettings.DeadLetterQueueSettings.IsQueueDurable,
exclusive: queueSettings.DeadLetterQueueSettings.IsQueueExclusive,
autoDelete: queueSettings.DeadLetterQueueSettings.DeleteQueueIfNoConsumers,
arguments: queueSettings.DeadLetterQueueSettings.QueueArguments);
}
public Queue(ISenderAgent senderAgent, IQueueEvents queueEvents, IMetaDataBusiness metaDataBusiness, IQueueSettings queueSettings)
{
_pointValidator = new PointValidator();
queueEvents.OnDebugMessageEvent($"Preparing new queue with target {senderAgent.TargetDescription}.");
_queueAction = new QueueAction(queueEvents, GetQueueInfo);
_senderAgent = senderAgent;
_queueEvents = queueEvents;
_metaDataBusiness = metaDataBusiness;
_queueSettings = queueSettings;
}
public void SetupQueue(IQueueSettings queueSettings)
{
CreateExchange(queueSettings);
CreateQueue(queueSettings);
CreateQueueExchangeBinding(queueSettings);
if (queueSettings.DeadLetterQueueSettings != null)
{
CreateDeadLetterQueue(queueSettings);
}
}
/// <summary>
/// Configure bus based on QueueSettings.
/// </summary>
/// <param name="queueSettings">QueueSettings</param>
/// <returns>IBusControl</returns>
private static IBusControl ConfigureBus(IQueueSettings queueSettings)
{
try
{
return(BusConfigurator.ConfigureBus(queueSettings));
}
catch (Exception e)
{
throw new Exception("BasePublisher.ConfigureBus : " + e.Message);
}
}
public async Task Configure(IQueueSettings settings)
{
Settings = settings;
_client = new QueueClient(Settings.ConnectionString, Settings.QueueName);
Response queue = await _client.CreateIfNotExistsAsync();
if (queue != null)
{
Console.WriteLine($"Fila {Settings.QueueName} foi criada");
}
}
public QueueListener(ILoggerFactory loggerFactory,
IQueueChannelManager queueChannelManager,
IQueueSettingsResolver queueSettingsResolver,
IQueueFactory queueFactory,
IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_logger = loggerFactory.GetLogger <QueueListener>();
_settings = queueSettingsResolver.GetSettings(nameof(QueueListener));
_channel = queueChannelManager.GetChannel();
_consumer = new EventingBasicConsumer(_channel);
queueFactory.SetupQueue(_settings);
}
/// <summary>
/// Build SendToUri based on QueueSettings.
/// </summary>
/// <param name="queueSettings">QueueSettings</param>
/// <returns>string Uri</returns>
private static string SendToUri(IQueueSettings queueSettings)
{
try
{
var uri = new StringBuilder(queueSettings.RabbitMqUri);
uri.Append(string.IsNullOrEmpty(queueSettings.VirtualHost) ? "" : queueSettings.VirtualHost + "/");
return(uri.ToString());
}
catch (Exception e)
{
throw new Exception("BasePublisher.SendToUri : " + e.Message);
}
}
public void CreateQueue(IQueueSettings queueSettings)
{
_queueChannelManager
.GetChannel()
.QueueDeclare(queue: queueSettings.QueueName,
durable: queueSettings.IsQueueDurable,
exclusive: queueSettings.IsQueueExclusive,
autoDelete: queueSettings.DeleteQueueIfNoConsumers,
arguments: new Dictionary <string, object>()
{
{ "x-message-ttl", 3600000 },
{ "x-dead-letter-exchange", "" },
{ "x-dead-letter-routing-key", queueSettings.DeadLetterQueueSettings?.RoutingKey }
});
}
/// <summary>
/// Send provided message to the specified queue.
/// </summary>
/// <typeparam name="T">Message Type</typeparam>
/// <param name="queueSettings">QueueSettings ojbect</param>
/// <param name="message">Message</param>
/// <param name="auditConnectionStringName">string Name of Connection String</param>
/// <param name="auditSchemaName">string Schema Name</param>
/// <param name="auditTableName">string Table Name (AuditRecord)</param>
/// <returns>Task object</returns>
public static async Task SendMessage <T>(IQueueSettings queueSettings, T message, DateTime?scheduledTime = null, string auditConnectionStringName = null, string auditSchemaName = null, string auditTableName = null) where T : class
{
try
{
//Check if the exchange and queues exist
if (ValidateExchange(queueSettings, message))
{
// Configure bus
var bus = ConfigureBus(queueSettings);
// Audit
// TODO: Audit store not implemented in POC, but all that really needs to be done is add a connection string to the config
// and point it to a table that matches the MassTransit audit table schema, MassTransit EntityFrameworkAuditStore will take care of creating the connection and writing to the table
if (auditConnectionStringName != null)
{
bus.ConnectSendAuditObservers(new EntityFrameworkAuditStore(auditConnectionStringName, auditSchemaName + "." + auditTableName), null);
}
// Helper function to construct destination uri
var sendToUri = SendToUri(queueSettings);
// If a scheduled time is provided, set the queue endpoint to the scheduler queue name other set it to the message type
var endPoint = (scheduledTime.HasValue) ?
await bus.GetSendEndpoint(new Uri(queueSettings.RabbitMqUri + queueSettings.VirtualHost + "/" + queueSettings.SchedulerQueueName))
: await bus.GetSendEndpoint(new Uri(sendToUri + queueSettings.QueueName));
//Start the bus
await bus.StartAsync();
// If a scheduled time is provided, MassTransit provides a ScheduleSend message to use, otherwise simply use Send
if (scheduledTime.HasValue)
{
await endPoint.ScheduleSend(new Uri(sendToUri + queueSettings.QueueName), scheduledTime.Value, message);
}
else
{
await endPoint.Send(message);
}
//Stop the bus
await bus.StopAsync();
}
}
catch (Exception e)
{
throw new Exception("BasePublisher.SendMessage : " + e.Message);
}
}
private void StartPollingQueue(IQueueSettings queueSettings)
{
queuePollers.Add(Task.Factory.StartNew(() =>
{
string queueLogInfo = string.Format("queue {0} in application {1}({2})", queueSettings.QueueName,
queueSettings.ApplicationName, queueSettings.ApplicationId);
try
{
var queuePoller = queuePollerFactory.Create(queueSettings, cancellationToken);
queuePoller.Poll();
}
catch (Exception err)
{
logger.Error("Failed in queue poller for {0} with error {1}", queueLogInfo, err);
throw;
}
}, cancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Default));
}
private long SaveDocument(IQueueSettings queueSettings, long originalId, MessageDocument retry, DateTime expiry)
{
long documentIdToReturn = -1;
using (var session = documentStore.OpenSessionForDefaultTenant())
{
MessageDocument originalMessage = null;
if (originalId > 0)
{
originalMessage = session.Load <MessageDocument>(originalId);
}
if (originalMessage != null)
{
if (originalMessage.Retries == null)
{
originalMessage.Retries = new List <MessageDocument>();
}
originalMessage.Retries.Add(retry);
if (retry.IsError)
{
originalMessage.AdditionalErrorStatus = AdditionalErrorStatus.Unresolved;
}
else
{
originalMessage.AdditionalErrorStatus = AdditionalErrorStatus.Resolved;
}
session.Advanced.GetMetadataFor(originalMessage)["Raven-Expiration-Date"] = new RavenJValue(expiry);
documentIdToReturn = originalMessage.Id;
logger.Trace(
"Added retry information with additional error status {0} to existing document with id {1} from {2}",
retry.AdditionalErrorStatus, originalMessage.Id, queueSettings.LogInfo);
}
else
{
session.Store(retry);
session.Advanced.GetMetadataFor(retry)["Raven-Expiration-Date"] = new RavenJValue(expiry);
documentIdToReturn = retry.Id;
logger.Trace("Saved new document for retry message with id {0} from {1}", retry.Id, queueSettings.LogInfo);
}
session.SaveChanges();
}
return(documentIdToReturn);
}
/// <summary>
/// Configures the bus based on QueueSettings
/// </summary>
/// <param name="queueSettings">QueueSettings objeect</param>
/// <param name="registrationAction"></param>
/// <returns>IBusControl</returns>
public static IBusControl ConfigureBus(IQueueSettings queueSettings, Action <IRabbitMqBusFactoryConfigurator, IRabbitMqHost> registrationAction = null)
{
return(Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(new Uri(queueSettings.RabbitMqUri + queueSettings.VirtualHost + "/"), hst =>
{
hst.Username(queueSettings.UserName);
hst.Password(queueSettings.Password);
});
cfg.ConfigureSend(x => x.UseSendExecute(context =>
{
context.Headers.Set("VirtualHost", queueSettings.VirtualHost);
context.Headers.Set("QueueName", queueSettings.QueueName);
}));
cfg.UseMessageScheduler(new Uri(queueSettings.RabbitMqUri + queueSettings.VirtualHost + "/" + queueSettings.SchedulerQueueName));
registrationAction?.Invoke(cfg, host);
}));
}
public QueuePoller(IQueueSettings queueSettings, CancellationToken cancellationToken, IRabbitConnectionFactory rabbitConnectionFactory,
IHeaderParser headerParser, IDocumentStore documentStore, IActiveQueuePollers activeQueuePollers, IStoreMessagesFactory storeMessagesFactory)
{
Verify.RequireNotNull(queueSettings, "queueSettings");
Verify.RequireNotNull(cancellationToken, "cancellationToken");
Verify.RequireNotNull(headerParser, "headerParser");
Verify.RequireNotNull(documentStore, "documentStore");
Verify.RequireNotNull(rabbitConnectionFactory, "rabbitConnectionFactory");
Verify.RequireNotNull(activeQueuePollers, "activeQueuePollers");
Verify.RequireNotNull(storeMessagesFactory, "storeMessagesFactory");
QueueSettings = queueSettings;
this.cancellationToken = cancellationToken;
this.rabbitConnectionFactory = rabbitConnectionFactory;
this.headerParser = headerParser;
this.documentStore = documentStore;
this.activeQueuePollers = activeQueuePollers;
this.storeMessagesFactory = storeMessagesFactory;
Key = Guid.NewGuid();
messageMeter = Metric.Meter(string.Format("RabbitOperations.QueuePoller.Messages.{0}.{1}", QueueSettings.ApplicationId, QueueSettings.QueueName), Unit.Items, TimeUnit.Seconds, tags: new MetricTags("QueuePoller"));
}
/// <summary>
/// Verify the exchange infrastructure exists.
/// </summary>
/// <typeparam name="T">Message Type</typeparam>
/// <param name="queueSettings">QueueSettings</param>
/// <param name="message">Message</param>
/// <returns>bool</returns>
private static bool ValidateExchange <T>(IQueueSettings queueSettings, T message)
{
try
{
//Setup RabbitMQ connection
var factory = new ConnectionFactory()
{
HostName = queueSettings.Host,
VirtualHost = queueSettings.VirtualHost,
UserName = queueSettings.UserName,
Password = queueSettings.Password
};
//Connect to RabbitMQ, will throw an exception for various reasons such as invalid credentials or trying to connect to an invalid virtual host
using (var connection = factory.CreateConnection())
{
using (var model = connection.CreateModel())
{
///PASSIVE QUEUE DECLARATION
///Using the passive declare methods, an exception is thrown if the queue/exchange does not exist
///This is important because we..
/// 1) Want to throw an appropriate exception if the queue doesnt exist
/// 2) Not allow automatic creation of queues based entirely on user input
/// 3) If the queue already exists, no exception is thrown
var messageContract = message.GetType().GetInterface("I" + message.GetType().Name);
model.ExchangeDeclarePassive(queueSettings.QueueName);
model.QueueDeclarePassive(queueSettings.QueueName);
}
}
return(true);
}
catch (Exception e)
{
throw new Exception("BasePublisher.VerifyExchangeExists : " + e.Message);
}
}
public QueueConsumerService(IQueueSettings queueSettings) : base(queueSettings)
{
}
public BaseQueueService(IQueueSettings queueSettings)
{
QueueSettings = queueSettings;
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="queueSettings"></param>
public Queue(IQueueSettings queueSettings)
{
QueueSettings = queueSettings;
}
public AzureQueueReceiverService(IQueueSettings settings)
{
Configure(settings).Wait();
}
public QueuePublisherService(IQueueSettings queueSettings) : base(queueSettings)
{
InitRabbitConnection();
InitConnectionChannel();
}