public void ShouldUseDeadLetterQueueOnException()
{
_subscriber = new RabbitMqSubscriber <string>(
new NullLogger <RabbitMqSubscriber <string> >(),
_settings)
.UseMiddleware(new ExceptionSwallowMiddleware <string>(new NullLogger <ExceptionSwallowMiddleware <string> >()))
.CreateDefaultBinding()
.SetMessageDeserializer(new DefaultStringDeserializer());
const string expected = "GetDefaultHost message";
SetupNormalQueue();
PublishToQueue(expected);
var completeLock = new ManualResetEventSlim(false);
var handler = new Func <string, Task>(s =>
{
completeLock.Set();
throw new Exception();
});
_subscriber.Subscribe(handler);
_subscriber.Start();
completeLock.Wait();
var result = ReadFromQueue(PoisonQueueName);
Assert.That(result, Is.EqualTo(expected));
}
public static IObservable <T> ReadAsJson <T>(RabbitMqSubscriptionSettings settings, ILogFactory log)
{
return(Observable.Create <T>(async(obs, ct) =>
{
var subscriber = new RabbitMqSubscriber <T>(
log,
settings,
new ResilientErrorHandlingStrategy(
settings: settings,
logFactory: log,
retryTimeout: TimeSpan.FromSeconds(10),
next: new DeadQueueErrorHandlingStrategy(log, settings)))
.SetMessageDeserializer(new JsonMessageDeserializer <T>())
.Subscribe(x =>
{
obs.OnNext(x);
return Task.CompletedTask;
})
.CreateDefaultBinding();
using (subscriber.Start())
{
var cts = new TaskCompletionSource <Unit>();
ct.Register(() => cts.SetResult(Unit.Default));
await cts.Task;
}
obs.OnCompleted();
}));
}
public void Start()
{
var settings = new RabbitMqSubscriptionSettings
{
ConnectionString = _settings.ConnectionString,
QueueName = _settings.QueueName,
ExchangeName = _settings.ExchangeName,
IsDurable = false
};
_subscriber = new RabbitMqSubscriber <TickPrice>(
_logFactory,
settings,
new ResilientErrorHandlingStrategy(
settings: settings,
logFactory: _logFactory,
retryTimeout: TimeSpan.FromSeconds(10)))
.SetMessageDeserializer(new JsonMessageDeserializer <TickPrice>())
.Subscribe(ProcessMessageAsync)
.CreateDefaultBinding();
_subscriber.Start();
_log.Info($"<< {nameof(TickPricesSubscriber)} is started.");
}
public void Start()
{
if (_enabled)
{
_messageProducer.Start();
}
}
public void Subscribe <TMessage>(IReloadingManager <RabbitConnectionSettings> settings, bool isDurable,
Func <TMessage, Task> handler)
{
// on-the fly connection strings switch is not supported currently for rabbitMq
var currSettings = settings.CurrentValue;
var subscriptionSettings = new RabbitMqSubscriptionSettings
{
ConnectionString = currSettings.ConnectionString,
QueueName =
$"{currSettings.ExchangeName}.{PlatformServices.Default.Application.ApplicationName}{currSettings.AdditionalQueueSuffix}",
ExchangeName = currSettings.ExchangeName,
IsDurable = isDurable,
};
var rabbitMqSubscriber = new RabbitMqSubscriber <TMessage>(subscriptionSettings,
new DefaultErrorHandlingStrategy(_logger, subscriptionSettings))
.SetMessageDeserializer(new JsonMessageDeserializer <TMessage>(JsonSerializerSettings))
.Subscribe(handler)
.SetLogger(_logger);
if (!_subscribers.TryAdd(subscriptionSettings.QueueName, rabbitMqSubscriber))
{
throw new InvalidOperationException(
$"A subscriber for queue {subscriptionSettings.QueueName} was already initialized");
}
rabbitMqSubscriber.Start();
}
public void Start()
{
var settings = new RabbitMqSubscriptionSettings
{
ConnectionString = _settings.ConnectionString,
ExchangeName = _settings.Exchange,
QueueName = $"{_settings.Exchange}.{_settings.QueueSuffix}",
IsDurable = false,
DeadLetterExchangeName = null
};
_subscriber = new RabbitMqSubscriber <TickPriceExt>(
_logFactory,
settings,
new ResilientErrorHandlingStrategy(
settings: settings,
logFactory: _logFactory,
retryTimeout: TimeSpan.FromSeconds(10),
next: new DeadQueueErrorHandlingStrategy(_logFactory, settings)))
.SetMessageDeserializer(new JsonMessageDeserializer <TickPriceExt>())
.Subscribe(HandleTickPrice)
.CreateDefaultBinding();
_subscriber.Start();
}
public void Subscribe <TMessage>(RabbitMqSettings settings, bool isDurable,
Func <TMessage, Task> handler, IMessageDeserializer <TMessage> deserializer)
{
var subscriptionSettings = new RabbitMqSubscriptionSettings
{
ConnectionString = settings.ConnectionString,
QueueName = QueueHelper.BuildQueueName(settings.ExchangeName, _env),
ExchangeName = settings.ExchangeName,
IsDurable = isDurable,
};
var rabbitMqSubscriber = new RabbitMqSubscriber <TMessage>(subscriptionSettings,
new DefaultErrorHandlingStrategy(_logger, subscriptionSettings))
.SetMessageDeserializer(deserializer)
.Subscribe(handler)
.SetLogger(_logger)
.SetConsole(_consoleWriter);
if (!_subscribers.TryAdd(subscriptionSettings, rabbitMqSubscriber))
{
throw new InvalidOperationException(
$"A subscriber for queue {subscriptionSettings.QueueName} was already initialized");
}
rabbitMqSubscriber.Start();
}
public void ShouldUseDeadLetterQueueOnException()
{
_subscriber = new RabbitMqSubscriber <string>(
EmptyLogFactory.Instance,
_settings,
new DeadQueueErrorHandlingStrategy(EmptyLogFactory.Instance, _settings))
.CreateDefaultBinding()
.SetMessageDeserializer(new DefaultStringDeserializer());
const string expected = "GetDefaultHost message";
SetupNormalQueue();
PublishToQueue(expected);
var completeLock = new ManualResetEventSlim(false);
var handler = new Func <string, Task>(s =>
{
completeLock.Set();
throw new Exception();
});
_subscriber.Subscribe(handler);
_subscriber.Start();
completeLock.Wait();
var result = ReadFromQueue(PoisonQueueName);
Assert.That(result, Is.EqualTo(expected));
}
public void Subscribe <TMessage>(RabbitConnectionSettings settings, bool isDurable,
Func <TMessage, Task> handler, IMessageDeserializer <TMessage> deserializer)
{
var subscriptionSettings = new RabbitMqSubscriptionSettings
{
ConnectionString = settings.ConnectionString,
QueueName =
$"{settings.ExchangeName}.{PlatformServices.Default.Application.ApplicationName}.{settings.RoutingKey ?? "all"}",
ExchangeName = settings.ExchangeName,
RoutingKey = settings.RoutingKey,
IsDurable = isDurable,
};
var rabbitMqSubscriber = new RabbitMqSubscriber <TMessage>(subscriptionSettings,
new DefaultErrorHandlingStrategy(_logger, subscriptionSettings))
.SetMessageDeserializer(deserializer)
.Subscribe(handler)
.SetLogger(_logger);
if (!_subscribers.TryAdd(subscriptionSettings.QueueName, rabbitMqSubscriber))
{
throw new InvalidOperationException(
$"A subscriber for queue {subscriptionSettings.QueueName} was already initialized");
}
rabbitMqSubscriber.Start();
}
public void Subscribe <TMessage>(IReloadingManager <RabbitConnectionSettings> settings, bool isDurable,
Func <TMessage, Task> handler)
{
// on-the fly connection strings switch is not supported currently for rabbitMq
var currSettings = settings.CurrentValue;
var subscriptionSettings = new RabbitMqSubscriptionSettings
{
ConnectionString = currSettings.ConnectionString,
QueueName =
$"{currSettings.ExchangeName}.{PlatformServices.Default.Application.ApplicationName}",
ExchangeName = currSettings.ExchangeName,
IsDurable = isDurable,
};
var rabbitMqSubscriber = new RabbitMqSubscriber <TMessage>(
_loggerFactory.CreateLogger <RabbitMqSubscriber <TMessage> >(),
subscriptionSettings)
.SetMessageDeserializer(new JsonMessageDeserializer <TMessage>(JsonSerializerSettings))
.Subscribe(handler)
.UseMiddleware(new ExceptionSwallowMiddleware <TMessage>(
_loggerFactory.CreateLogger <ExceptionSwallowMiddleware <TMessage> >()))
.SetReadHeadersAction(_correlationManager.FetchCorrelationIfExists);
if (!_subscribers.TryAdd(subscriptionSettings.QueueName, rabbitMqSubscriber))
{
throw new InvalidOperationException(
$"A subscriber for queue {subscriptionSettings.QueueName} was already initialized");
}
rabbitMqSubscriber.Start();
}
public void Start()
{
if (!_enabled)
{
return;
}
_rabbit.Start();
_log.WriteInfoAsync(nameof(IcmTickPriceHarvester), "Initializing", "", "Started");
}
public void Start()
{
if (!_config.RabbitMq.TickPrices.Enabled && !_config.RabbitMq.OrderBooks.Enabled)
{
return;
}
_rabbit.Start();
_log.WriteInfoAsync(nameof(ICMTickPriceHarvester), "Initializing", "", "Started");
}
static void Main(string[] args)
{
Console.Title = typeof(Program).Assembly.GetName().Name;
Log.Logger = new LoggerConfiguration()
.WriteTo.File($"C:\\RealTimeHimFileDropTest\\Logs\\{DateTime.Now.ToString("MM_dd_yyyy")}_{Environment.UserName}.{typeof(Program).Assembly.GetName().Name}.log")
.CreateLogger();
var subscriber = new RabbitMqSubscriber(GetSettings());
subscriber.Start();
}
public void ReceivingMessagesWhenOneRabbitIsNotReachable()
{
// arrange
var settings = new RabbitMqSubscriptionSettings
{
ConnectionString = InvalidConnectionString,
ExchangeName = ExchangeName,
IsDurable = true,
QueueName = QueueName
};
_subscriber = new RabbitMqSubscriber <string>(
EmptyLogFactory.Instance,
settings,
new DefaultErrorHandlingStrategy(EmptyLogFactory.Instance, settings))
.SetMessageDeserializer(new DefaultStringDeserializer())
.SetMessageReadStrategy(new MessageReadQueueStrategy())
.SetAlternativeExchange(AlternativeConnectionString)
.SetDeduplicator(new InMemoryDeduplcator())
.CreateDefaultBinding();
var handler = new Func <string, Task>(s =>
{
_messagesCount++;
return(Task.CompletedTask);
});
_subscriber.Subscribe(handler);
_subscriber.Start();
// act
{
var factory = new ConnectionFactory {
Uri = new Uri(AlternativeConnectionString)
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.BasicPublish(ExchangeName, "", body: Encoding.UTF8.GetBytes("1"));
channel.BasicPublish(ExchangeName, "", body: Encoding.UTF8.GetBytes("3"));
channel.BasicPublish(ExchangeName, "", body: Encoding.UTF8.GetBytes("4"));
}
}
Thread.Sleep(TimeSpan.FromSeconds(2));
// assert
Assert.AreEqual(3, _messagesCount);
}
public void Start()
{
var settings = RabbitMqSubscriptionSettings
.ForSubscriber(_connectionString, _exchangeName, "tradesconverter")
.MakeDurable()
.UseRoutingKey(((int)MessageType.Order).ToString());
_subscriber = new RabbitMqSubscriber <ExecutionEvent>(
settings,
new ResilientErrorHandlingStrategy(_log, settings,
retryTimeout: TimeSpan.FromSeconds(10),
next: new DeadQueueErrorHandlingStrategy(_log, settings)))
.SetMessageDeserializer(new ProtobufMessageDeserializer <ExecutionEvent>())
.SetMessageReadStrategy(new MessageReadQueueStrategy())
.Subscribe(ProcessMessageAsync)
.CreateDefaultBinding()
.SetLogger(_log);
#if !DEBUG
_subscriber.Start();
#endif
}
public void SuccessfulPath()
{
const string expected = "GetDefaultHost message";
string result = null;
SetupNormalQueue();
var completeLock = new ManualResetEventSlim(false);
var handler = new Func <string, Task>(s =>
{
result = s;
completeLock.Set();
return(Task.CompletedTask);
});
_subscriber.Subscribe(handler);
_subscriber.Start();
PublishToQueue(expected);
completeLock.Wait();
Assert.That(result, Is.EqualTo(expected));
}
public void ReceivingAndDeduplicationMessagesFromBothExchanges()
{
// arrange
var settings = new RabbitMqSubscriptionSettings
{
ConnectionString = ConnectionString,
ExchangeName = ExchangeName,
IsDurable = true,
QueueName = QueueName
};
_subscriber = new RabbitMqSubscriber <string>(
new NullLogger <RabbitMqSubscriber <string> >(),
settings)
.UseMiddleware(new InMemoryDeduplicationMiddleware <string>())
.UseMiddleware(new ExceptionSwallowMiddleware <string>(new NullLogger <ExceptionSwallowMiddleware <string> >()))
.SetMessageDeserializer(new DefaultStringDeserializer())
.SetMessageReadStrategy(new MessageReadQueueStrategy())
.SetAlternativeExchange(AlternativeConnectionString)
.CreateDefaultBinding();
var handler = new Func <string, Task>(s =>
{
_messagesCount++;
return(Task.CompletedTask);
});
_subscriber.Subscribe(handler);
_subscriber.Start();
// act
{
var factory = new ConnectionFactory {
Uri = new Uri(ConnectionString, UriKind.Absolute)
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.BasicPublish(ExchangeName, "", body: Encoding.UTF8.GetBytes("1"));
channel.BasicPublish(ExchangeName, "", body: Encoding.UTF8.GetBytes("2"));
channel.BasicPublish(ExchangeName, "", body: Encoding.UTF8.GetBytes("4"));
}
}
{
var factory = new ConnectionFactory {
Uri = new Uri(AlternativeConnectionString, UriKind.Absolute)
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.BasicPublish(ExchangeName, "", body: Encoding.UTF8.GetBytes("1"));
channel.BasicPublish(ExchangeName, "", body: Encoding.UTF8.GetBytes("3"));
channel.BasicPublish(ExchangeName, "", body: Encoding.UTF8.GetBytes("4"));
}
}
Thread.Sleep(TimeSpan.FromSeconds(2));
// assert
Assert.AreEqual(4, _messagesCount);
}
public void Start()
{
_connector.Start();
}
