public void Queue_should_not_be_deleted_if_expires_is_not_set()
{
var bus = RabbitHutch.CreateBus("host=localhost");
var subscriptionId = "TestSubscriptionWithoutExpires";
var conventions = new Conventions(new DefaultTypeNameSerializer());
var queueName = conventions.QueueNamingConvention(typeof(MyMessage), subscriptionId);
var client = new ManagementClient("http://localhost", "guest", "guest");
var vhost = new Vhost {
Name = "/"
};
bus.Subscribe <MyMessage>(subscriptionId, message => { });
var queue = client.GetQueue(queueName, vhost);
queue.Should().NotBeNull();
// this will abandon the queue... poor queue!
bus.Dispose();
Thread.Sleep(1500);
queue = client.GetQueue(queueName, vhost);
queue.Should().NotBeNull();
}
public Task DisableTracingAsync(Vhost vhost,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(vhost, nameof(vhost));
vhost.Tracing = false;
return(PutAsync <Vhost>($"vhosts/{SanitiseVhostName(vhost.Name)}", vhost, cancellationToken));
}
public BusManager(string username, string password, string host = _defaultHost, bool tearDownQueues = false)
{
_locker = new object();
_dtoConverter = new DTOConverter();
_handlerManager = new HandlerManager();
_queueSubscriptions = new ConcurrentDictionary <string, IDisposable>();
_connectionString = string.Format("host={0};port={1};username={2};password={3};virtualHost={4};timeout={5};requestedHeartbeat=0", host, _port.ToString(), username, password, _virtualhost, _timeout.ToString());
try
{
//Connect to bus
Connect();
//Setup management client
_manageClient = new ManagementClient(host, _adminUser, _adminPassword);
_vhost = _manageClient.GetVhost(_virtualhost);
//Create cached queues list
_cachedQueues = new ConcurrentDictionary <IQueue, byte>();
//Have to do this whatever happens
InitialiseExchanges();
//Initialise queues
InitialiseQueues(tearDownQueues);
}
catch (Exception ex)
{
HandleException(ex, true);
}
}
public Task DeleteVhostAsync(Vhost vhost,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(vhost, nameof(vhost));
return(DeleteAsync($"vhosts/{SanitiseVhostName(vhost.Name)}", cancellationToken));
}
public async Task DeleteVirtualHostAsync(Vhost vhost,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(vhost, nameof(vhost));
await DeleteAsync($"vhosts/{vhost.Name}", cancellationToken).ConfigureAwait(false);
}
public PermissionInfo(User user, Vhost vhost)
{
this.user = user;
this.vhost = vhost;
Configure = Write = Read = allowAll;
}
private async Task <Queue> CreateTestQueueInVhost(string queueName, Vhost vhost)
{
var queueInfo = new QueueInfo(queueName);
await managementClient.CreateQueueAsync(queueInfo, vhost).ConfigureAwait(false);
return(await managementClient.GetQueueAsync(queueName, vhost).ConfigureAwait(false));
}
public PermissionInfo(User user, Vhost vhost)
{
this.user = user;
this.vhost = vhost;
Configure = Write = Read = allowAll;
}
public void Should_alert_for_each_error_queue_in_each_vhost()
{
var vhost2 = new Vhost {
Name = "my_other_vhost"
};
ManagementClient.Stub(x => x.GetVHosts()).Return(new[]
{
vhost,
vhost2
});
var queue = new Queue
{
Messages = 1
};
ManagementClient.Stub(x => x.GetQueue("EasyNetQ_Default_Error_Queue", vhost)).Return(queue);
ManagementClient.Stub(x => x.GetQueue("EasyNetQ_Default_Error_Queue", vhost2)).Return(queue);
var result = easyNetQErrorQueueCheck.RunCheck(ManagementClient);
result.Alert.ShouldBeTrue();
result.Message.ShouldEqual("broker 'http://the.broker.com', VHost(s): 'my_vhost, my_other_vhost' has messages on the EasyNetQ error queue.");
}
public void Queue_should_be_deleted_after_the_expires_ttl()
{
Assert.Throws <UnexpectedHttpStatusCodeException>(() =>
{
var bus = RabbitHutch.CreateBus("host=localhost");
var subscriptionId = "TestSubscriptionWithExpires";
var conventions = new Conventions(new DefaultTypeNameSerializer());
var queueName = conventions.QueueNamingConvention(typeof(MyMessage), subscriptionId);
var client = new ManagementClient("http://localhost", "guest", "guest");
var vhost = new Vhost {
Name = "/"
};
bus.Subscribe <MyMessage>(subscriptionId, message => { }, x => x.WithExpires(1000));
var queue = client.GetQueue(queueName, vhost);
queue.Should().NotBeNull();
// this will abandon the queue... poor queue!
bus.Dispose();
Thread.Sleep(1500);
queue = client.GetQueue(queueName, vhost);
queue.Should().BeNull();
});
}
public async Task DeletePolicyAsync(string policyName, Vhost vhost,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(policyName, nameof(policyName));
Ensure.ArgumentNotNull(vhost, nameof(vhost));
await DeleteAsync(GetPolicyUrl(policyName, vhost.Name), cancellationToken).ConfigureAwait(false);
}
public async Task EnableTracingAsync(Vhost vhost,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(vhost, nameof(vhost));
vhost.Tracing = true;
await PutAsync <Vhost>($"vhosts/{SanitiseVhostName(vhost.Name)}", vhost, cancellationToken)
.ConfigureAwait(false);
}
public Task <Exchange> GetExchangeAsync(string exchangeName, Vhost vhost, GetRatesCriteria ratesCriteria = null,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(exchangeName, nameof(exchangeName));
Ensure.ArgumentNotNull(vhost, nameof(vhost));
return(GetAsync <Exchange>($"exchanges/{SanitiseVhostName(vhost.Name)}/{exchangeName}", ratesCriteria?.ToQueryParameters(), cancellationToken));
}
public Task DeletePolicyAsync(string policyName, Vhost vhost,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(policyName, nameof(policyName));
Ensure.ArgumentNotNull(vhost, nameof(vhost));
return(DeleteAsync(GetPolicyUrl(policyName, vhost.Name), cancellationToken));
}
public async Task Should_be_able_to_get_an_individual_exchange_by_name()
{
var vhost = new Vhost {
Name = vhostName
};
var exchange = await managementClient.GetExchangeAsync(testExchange, vhost).ConfigureAwait(false);
exchange.Name.ShouldEqual(testExchange);
}
public void Should_be_able_to_get_a_queue_by_name()
{
var vhost = new Vhost {
Name = vhostName
};
var queue = managementClient.GetQueue(testQueue, vhost);
queue.Name.ShouldEqual(testQueue);
}
public void Should_be_able_to_get_a_queue_by_name_with_plus_char()
{
var vhost = new Vhost {
Name = vhostName
};
var queue = managementClient.GetQueue(testQueueWithPlusChar, vhost);
queue.Name.ShouldEqual(testQueueWithPlusChar);
}
public void DeleteVirtualHost(Vhost vhost)
{
if (vhost == null)
{
throw new ArgumentNullException("vhost");
}
Delete(string.Format("vhosts/{0}", vhost.Name));
}
public void Should_be_able_to_get_an_individual_exchange_by_name()
{
var vhost = new Vhost {
Name = vhostName
};
var exchange = managementClient.GetExchange(testExchange, vhost);
exchange.Name.ShouldEqual(testExchange);
}
public Task <Queue> GetQueueAsync(string queueName, Vhost vhost, GetLengthsCriteria lengthsCriteria = null,
GetRatesCriteria ratesCriteria = null, CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(queueName, nameof(queueName));
Ensure.ArgumentNotNull(vhost, nameof(vhost));
return(GetAsync <Queue>($"queues/{SanitiseVhostName(vhost.Name)}/{SanitiseName(queueName)}",
cancellationToken, lengthsCriteria, ratesCriteria));
}
public void SetUp()
{
user = new User {
Name = "mikey"
};
vhost = new Vhost {
Name = "theVHostName"
};
permissionInfo = new PermissionInfo(user, vhost);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = base.GetHashCode();
hashCode = (hashCode * 397) ^ (Vhost != null ? Vhost.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (User != null ? User.GetHashCode() : 0);
return(hashCode);
}
}
public TopicPermissionInfoTests()
{
user = new User {
Name = "mikey"
};
vhost = new Vhost {
Name = "theVHostName"
};
topicPermissionInfo = new TopicPermissionInfo(user, vhost);
}
private Exchange CreateExchange(string exchangeName)
{
var vhost = new Vhost {
Name = vhostName
};
var exchangeInfo = new ExchangeInfo(exchangeName, "direct");
var exchange = managementClient.CreateExchange(exchangeInfo, vhost);
return(exchange);
}
public async Task <bool> IsAliveAsync(Vhost vhost,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(vhost, nameof(vhost));
var result = await GetAsync <AlivenessTestResult>($"aliveness-test/{SanitiseVhostName(vhost.Name)}",
cancellationToken).ConfigureAwait(false);
return(result.Status == "ok");
}
public void Should_be_able_to_create_an_exchange()
{
var vhost = new Vhost {
Name = "/"
};
var exchangeInfo = new ExchangeInfo(testExchange, "direct");
var exchange = managementClient.CreateExchange(exchangeInfo, vhost);
exchange.Name.ShouldEqual(testExchange);
}
/// <summary>
/// Removes all messages from the queue.
/// </summary>
/// <param name="queue">The queue from which to delete messages.</param>
public void PurgeQueue(ServiceBusQueue queue)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
Vhost vhost = _managementClient.GetVhostAsync(queue.VHost).Result;
RabbitMQQueue rmqQueue = _managementClient.GetQueueAsync(queue.Name, vhost).Result;
_managementClient.PurgeAsync(rmqQueue).Wait();
}
public bool IsAlive(Vhost vhost)
{
if (vhost == null)
{
throw new ArgumentNullException("vhost");
}
var result = Get <AlivenessTestResult>(string.Format("aliveness-test/{0}",
SanitiseVhostName(vhost.Name)));
return(result.Status == "ok");
}
public async Task <Exchange> CreateExchangeAsync(ExchangeInfo exchangeInfo, Vhost vhost,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(vhost, nameof(exchangeInfo));
Ensure.ArgumentNotNull(vhost, nameof(vhost));
await PutAsync($"exchanges/{SanitiseVhostName(vhost.Name)}/{SanitiseName(exchangeInfo.GetName())}",
exchangeInfo, cancellationToken).ConfigureAwait(false);
return(await GetExchangeAsync(SanitiseName(exchangeInfo.GetName()), vhost,
cancellationToken : cancellationToken).ConfigureAwait(false));
}
public async Task <Queue> CreateQueueAsync(QueueInfo queueInfo, Vhost vhost,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(queueInfo, nameof(queueInfo));
Ensure.ArgumentNotNull(vhost, nameof(vhost));
await PutAsync($"queues/{SanitiseVhostName(vhost.Name)}/{SanitiseName(queueInfo.GetName())}", queueInfo,
cancellationToken).ConfigureAwait(false);
return(await GetQueueAsync(queueInfo.GetName(), vhost, cancellationToken : cancellationToken)
.ConfigureAwait(false));
}
public void Should_be_able_to_get_a_queue_by_name_with_detailed_length_information()
{
var age = 60;
var increment = 10;
var vhost = new Vhost {
Name = vhostName
};
var queue = managementClient.GetQueue(testQueue, vhost, lengthsCriteria: new GetLengthsCriteria(age, increment));
queue.Name.ShouldEqual(testQueue);
queue.MessagesDetails.Samples.Count.ShouldEqual(7);
queue.MessagesReadyDetails.Samples.Count.ShouldEqual(7);
queue.MessagesUnacknowledgedDetails.Samples.Count.ShouldEqual(7);
}
