public async Task SimplePublish()
{
const string expected = "GetDefaultHost message";
_publisher.Start();
SetupNormalQueue();
await _publisher.ProduceAsync(expected);
var result = ReadFromQueue();
Assert.That(result, Is.EqualTo(expected));
}
public Common.IMessageProducer <TMessage> GetProducer <TMessage>(IReloadingManager <RabbitConnectionSettings> settings,
bool isDurable, IRabbitMqSerializer <TMessage> serializer)
{
// on-the fly connection strings switch is not supported currently for rabbitMq
var currSettings = settings.CurrentValue;
var subscriptionSettings = new RabbitMqSubscriptionSettings
{
ConnectionString = currSettings.ConnectionString,
ExchangeName = currSettings.ExchangeName,
IsDurable = isDurable,
};
return((Common.IMessageProducer <TMessage>)_producers.GetOrAdd(subscriptionSettings, CreateProducer).Value);
Lazy <IStartStop> CreateProducer(RabbitMqSubscriptionSettings s)
{
// Lazy ensures RabbitMqPublisher will be created and started only once
// https://andrewlock.net/making-getoradd-on-concurrentdictionary-thread-safe-using-lazy/
return(new Lazy <IStartStop>(() =>
{
var result = new RabbitMqPublisher <TMessage>(_loggerFactory, s).DisableInMemoryQueuePersistence()
.SetSerializer(serializer)
.SetWriteHeadersFunc(_correlationManager.BuildCorrelationHeadersIfExists);
result.Start();
return result;
}));
}
}
public static void Example(RabbitMqSubscriptionSettings settings)
{
var connection = new RabbitMqPublisher <string>(new NullLoggerFactory(), settings)
.SetSerializer(new TestMessageSerializer())
.SetPublishStrategy(new DefaultFanoutPublishStrategy(settings));
connection.Start();
for (var i = 0; i <= 10; i++)
{
connection.ProduceAsync("message#" + i);
}
}
public static void UseEmailSenderViaRabbitMq(this IServiceCollection serviceCollection,
RabbitMqSettings rabbitMqSettings, ILog log)
{
var rabbitMqBroker
= new RabbitMqPublisher <EmailModel>(rabbitMqSettings)
.SetLogger(log)
.SetSerializer(new EmailRabbitMqSerializer());
serviceCollection.AddSingleton <IEmailSender>(
new EmailSenderViaQueue(rabbitMqBroker));
rabbitMqBroker.Start();
}
public void Start()
{
var settings = RabbitMqSubscriptionSettings.CreateForPublisher(_settings.ConnectionString, _settings.ExchangeOrderBook);
settings.ExchangeName = _settings.ExchangeOrderBook;
settings.DeadLetterExchangeName = string.Empty;
settings.IsDurable = false;
_publisher = new RabbitMqPublisher <OrderBook>(_logFactory, settings, false)
.DisableInMemoryQueuePersistence()
.SetSerializer(new JsonMessageSerializer <OrderBook>())
.SetPublishStrategy(new DefaultFanoutPublishStrategy(settings))
.SetConsole(new LogToConsole());
_publisher.Start();
}
public async Task PublishAsync(List <TradeLogItem> message)
{
await _lock.WaitAsync();
try
{
var publishStart = DateTime.UtcNow;
await _publisher.ProduceAsync(message);
var publishTime = DateTime.UtcNow.Subtract(publishStart);
if (publishTime > _timeThreshold)
{
_log.WriteWarning(nameof(TradesPublisher), nameof(PublishAsync), $"Long publish ({publishTime}): {message.ToJson()}");
_publisher.Stop();
_publisher.Start();
}
}
finally
{
_lock.Release();
}
}
private void RegisterPublishers(ContainerBuilder builder, IConsole consoleWriter)
{
var publishers = new List <string>
{
_settings.RabbitMqQueues.OrderHistory.ExchangeName,
_settings.RabbitMqQueues.OrderbookPrices.ExchangeName,
_settings.RabbitMqQueues.AccountMarginEvents.ExchangeName,
_settings.RabbitMqQueues.AccountStats.ExchangeName,
_settings.RabbitMqQueues.Trades.ExchangeName,
_settings.RabbitMqQueues.PositionHistory.ExchangeName,
_settings.RabbitMqQueues.ExternalOrder.ExchangeName,
};
var bytesSerializer = new BytesStringSerializer();
foreach (var exchangeName in publishers)
{
builder
.Register(ctx =>
{
var pub = new RabbitMqPublisher <string>(ctx.Resolve <ILoggerFactory>(), new RabbitMqSubscriptionSettings
{
ConnectionString = _settings.MtRabbitMqConnString,
ExchangeName = exchangeName
})
.SetSerializer(bytesSerializer)
.SetPublishStrategy(new DefaultFanoutPublishStrategy(new RabbitMqSubscriptionSettings {
IsDurable = true
}))
.DisableInMemoryQueuePersistence()
.SetWriteHeadersFunc(ctx.Resolve <RabbitMqCorrelationManager>().BuildCorrelationHeadersIfExists);
pub.Start();
return(pub);
})
.Named <IMessageProducer <string> >(exchangeName)
.As <IStartStop>()
.SingleInstance();
}
}
public ActivityService(RabbitMqPublisher <SessionActivity> publisher)
{
this.publisher = publisher;
publisher.Start();
}
public void QueuePersistenceShouldBeConfiguredExplicitly()
{
Assert.Throws <InvalidOperationException>(() => _publisher.Start());
_publisher.Stop();
}
