public async Task Then_If_The_Status_Has_Changed_To_Error_On_Some_Of_The_Queues_Then_A_Degraded_Response_Is_Returned_With_The_Queues_Listed(
[Frozen] Mock <IAzureQueueService> azureQueueService,
HealthCheckContext healthCheckContext,
QueueHealthCheck handler
)
{
//Arrange
var expectedQueueName = "test.queue";
var expectedQueueName2 = "test.queue2";
var expectedQueueName3 = "test.queue3";
var queueMonitor = new QueueMonitor(expectedQueueName, true);
var queueMonitor2 = new QueueMonitor(expectedQueueName2, true);
var queueMonitor3 = new QueueMonitor(expectedQueueName3, true);
azureQueueService.Setup(x => x.GetQueuesToMonitor()).Returns(new List <QueueMonitor>
{
queueMonitor,
queueMonitor2,
queueMonitor3
});
azureQueueService.SetupSequence(x => x.IsQueueHealthy(It.IsAny <string>()))
.ReturnsAsync(false).ReturnsAsync(false).ReturnsAsync(true);
//Act
var actual = await handler.CheckHealthAsync(healthCheckContext, CancellationToken.None);
//Assert
azureQueueService.Verify(x => x.IsQueueHealthy(expectedQueueName), Times.Once);
Assert.AreEqual(HealthStatus.Degraded, actual.Status);
Assert.IsTrue(actual.Data.ContainsKey("QueuesInError"));
Assert.AreEqual("test.queue, test.queue2", actual.Data["QueuesInError"]);
}
private static void StartQueueMonitoring()
{
var monitor = new QueueMonitor();
monitor.AddComponents(MonitoredConsumers);
monitor.Start();
}
static void Main(string[] args)
{
var rabbitOptions = new RabbitOptions
{
HostName = RabbitHostName,
ExchangeName = RabbitExchangeName,
ExchangeAutoDelete = true,
ExchangeDurable = false
};
var reader = new RabbitMessageReader(rabbitOptions);
var converter = new RabbitMessageConverter();
var source = new ResourceValidatorSource(typeof(Program).Assembly, "Console.Rabbit.Schemas.{messageType}.json");
var output = new ConsoleValidationOutput();
var monitor = new QueueMonitor(reader, converter, new MessageValidator(source), output);
monitor.Start();
var publisher = new Publisher(RabbitHostName, RabbitExchangeName);
publisher.Start();
System.Console.WriteLine("Monitoring {0} on {1}. Press any key to stop.", rabbitOptions.ExchangeName, rabbitOptions.HostName);
System.Console.ReadKey();
System.Console.WriteLine("Stopping...");
publisher.Stop();
monitor.Stop();
}
void RemoveQueueFromGroup(object state)
{
QueueMonitor monitor = (QueueMonitor)state;
lock (this.thisLock)
{
this.monitors.Remove(monitor);
monitor.Dispose();
}
}
public Tests()
{
var source = new ResourceValidatorSource(GetType().Assembly, "Testing.PostTest.Xunit.Schemas.{messageType}.json");
_queue = new InMemoryMessageReader();
_output = new InMemoryValidationOutput();
_monitor = new QueueMonitor(_queue, new DirectMessageConverter(), new MessageValidator(source), _output);
_monitor.Start();
}
public AcceptanceTests()
{
_messages = new InMemoryMessageReader();
_output = new InMemoryValidationOutput();
_validators = new InMemoryValidationSource();
var converter = new DirectMessageConverter();
var validator = new MessageValidator(_validators);
_queueMonitor = new QueueMonitor(_messages, converter, validator, _output);
_queueMonitor.Start();
}
protected override void OnStart(string[] args)
{
// replace these with your own adapters
IMessageReader reader = new InMemoryMessageReader();
IMessageConverter converter = new DirectMessageConverter();
IValidatorSource source = new FileValidatorSource(Path.Combine(_baseDirectory, "validators"));
var output = new SerilogValidationOutput();
_monitor = new QueueMonitor(reader, converter, new MessageValidator(source), output);
_monitor.Start();
}
public void ScheduleRetry(QueueMonitor monitor)
{
lock (this.thisLock)
{
this.failedMonitors.Add(monitor);
if (!this.retryScheduled)
{
this.retryTimer.Set(RetryMonitorInterval);
this.retryScheduled = true;
}
}
}
public bool Start(HostControl hostControl)
{
var runtime = _config.GetConfigSection("HareShowRuntimeSettings/EventTrigger");
// TODO: get start datetime from app.config
DateTime startDateTime;
if (string.IsNullOrWhiteSpace(runtime.Get("startDateTime")))
{
startDateTime = DateTime.Now;
}
else
{
if (!DateTime.TryParse(runtime.Get("startDateTime"), out startDateTime))
{
// TODO: if the start datetime is bad then throw an exception here
}
}
// TODO: get interval from app.config
TimeSpan interval;
if (!TimeSpan.TryParse(runtime.Get("runInterval"), out interval))
{
// TODO: if the interval time is bad then throw an exception here
}
// TODO: get username and password from app.config
var hareDuCredentials = _config.GetConfigSection("HareDuSettings/Login");
if (string.IsNullOrWhiteSpace(hareDuCredentials.Get("username")) ||
string.IsNullOrWhiteSpace(hareDuCredentials.Get("password")))
{
throw new UserCredentialsInvalidException(
"Not able to connect to RabbitMQ because username or password is invalid.");
}
string username = hareDuCredentials.Get("username");
string password = hareDuCredentials.Get("password");
_scheduler.Schedule <QueueMonitorJob>(Guid.NewGuid(), new DateTimeOffset(startDateTime), interval, username, password);
var monitor = new QueueMonitor(_client);
var security = new SecurityImpl();
_scheduler.JobFactory = new HareShowJobFactory <IQueueMonitor, ISecurity, QueueMonitorJob>(monitor, security);
_scheduler.Start();
return(true);
}
object AddQueueToGroup(Uri queue)
{
QueueMonitor monitor = null;
lock (this.thisLock)
{
monitor = new QueueMonitor(queue, this);
this.monitors.Add(monitor);
if (this.enabled)
{
monitor.Start();
}
}
return(monitor);
}
public async Task Then_If_The_Status_Has_Not_Been_Set_And_Unhealthy_A_Unhealthy_Response_Is_Returned(
[Frozen] Mock <IAzureQueueService> azureQueueService,
HealthCheckContext healthCheckContext,
QueueHealthCheck handler
)
{
//Arrange
var expectedQueueName = "test.queue";
var queueMonitor = new QueueMonitor(expectedQueueName, null);
azureQueueService.Setup(x => x.GetQueuesToMonitor()).Returns(new List <QueueMonitor>
{
queueMonitor
});
azureQueueService.Setup(x => x.IsQueueHealthy(expectedQueueName)).ReturnsAsync(false);
//Act
var actual = await handler.CheckHealthAsync(healthCheckContext, CancellationToken.None);
//Assert
azureQueueService.Verify(x => x.IsQueueHealthy(expectedQueueName), Times.Once);
Assert.AreEqual(HealthStatus.Unhealthy, actual.Status);
}
static void Main(string[] args)
{
var d = new Dispatcher();
var midgetHouse = new MidgetHouse(d);
d.Subscribe<OrderPlaced>(midgetHouse);
d.Subscribe<DodgyOrderPlaced>(midgetHouse);
var manager = new Manager();
var cashier = new Cashier(d);
var ass = new AssMan(d);
var cookDispatcher = new SmartDispatcher<CookFood>();
var cookTtlGate = new TimeToLiveGate<CookFood>(cookDispatcher);
var cookQueudHandler = new QueuedHandler<CookFood>(cookTtlGate, "cook ttl gate");
var cookLimiter = new Limiter<CookFood>(cookQueudHandler);
//var cookScrewsUp = new ScrewsUp<CookFood>(cookLimiter);
var alarmClock = new AlarmClock(d);
var messageMonitor = new MessageMonitor(d);
var fmm = new FilePerOrderMonitor(d);
d.Subscribe(alarmClock);
d.Subscribe(cookLimiter);
d.Subscribe(ass);
d.Subscribe(cashier);
d.Subscribe(manager);
d.Subscribe<OrderPlaced>(messageMonitor);
d.Subscribe<DodgyOrderPlaced>(messageMonitor);
d.Subscribe<OrderPlaced>(fmm);
d.Subscribe<DodgyOrderPlaced>(fmm);
var cookQueudHandler1 = new QueuedHandler<CookFood>(new Cook(d, 10000), "c1");
cookDispatcher.AddHandler(cookQueudHandler1);
var cookQueudHandler2 = new QueuedHandler<CookFood>(new Cook(d, 5000), "c2");
cookDispatcher.AddHandler(cookQueudHandler2);
var cookQueudHandler3 = new QueuedHandler<CookFood>(new Cook(d, 100), "c3");
cookDispatcher.AddHandler(cookQueudHandler3);
var queueMonitor = new QueueMonitor(new IAmMonitored[] {cookQueudHandler1, cookQueudHandler2, cookQueudHandler3, cookQueudHandler,d.QueudHandler});
//Cook cook = new Cook(ass);
var waiter = new Waiter(d);
cookQueudHandler1.Start();
cookQueudHandler2.Start();
cookQueudHandler3.Start();
cookQueudHandler.Start();
d.Start();
alarmClock.Start();
queueMonitor.Start();
new Thread(TryPay).Start(cashier);
Random r = new Random();
for (int i = 0; i < 500; i++)
{
Guid orderNumber;
if (r.Next()%2 == 0)
{
orderNumber = waiter.PlaceDodgyOrder(new[] {Tuple.Create("Burger", 1)}, 15);
}
else
{
orderNumber = waiter.PlaceOrder(new[] { Tuple.Create("Burger", 1) }, 15);
}
if(i > 2)Thread.Sleep(2000);
orders.TryAdd(orderNumber, null);
}
//var orderNumber = waiter.PlaceOrder(new[] {Tuple.Create("Burger", 1)}, 15);
//cashier.PayForOrder(orderNumber);
Console.ReadLine();
}
object AddQueueToGroup(Uri queue)
{
QueueMonitor monitor = null;
lock (this.thisLock)
{
monitor = new QueueMonitor(queue, this);
this.monitors.Add(monitor);
if (this.enabled)
{
monitor.Start();
}
}
return monitor;
}
public void ScheduleRetry(QueueMonitor monitor)
{
lock (this.thisLock)
{
this.failedMonitors.Add(monitor);
if (!this.retryScheduled)
{
this.retryTimer.Set(RetryMonitorInterval);
this.retryScheduled = true;
}
}
}
