public RabbitMqSendSettings(RabbitMqEndpointAddress address)
: base(address.Name, address.ExchangeType, address.Durable, address.AutoDelete)
{
_exchangeBindings = new List <ExchangeBindingPublishTopologySpecification>();
QueueArguments = new Dictionary <string, object>();
if (address.BindToQueue)
{
BindToQueue(address.QueueName);
}
if (!string.IsNullOrWhiteSpace(address.DelayedType))
{
SetExchangeArgument("x-delayed-type", address.DelayedType);
}
if (address.BindExchanges != null)
{
foreach (var exchange in address.BindExchanges)
{
BindToExchange(exchange);
}
}
if (!string.IsNullOrWhiteSpace(address.AlternateExchange))
{
SetExchangeArgument("alternate-exchange", address.AlternateExchange);
}
}
async Task <ISendTransport> ISendTransportProvider.GetSendTransport(Uri address)
{
var endpointAddress = new RabbitMqEndpointAddress(_host.Address, address);
var transport = await _host.CreateSendTransport(endpointAddress, _modelContextSupervisor).ConfigureAwait(false);
return(transport);
}
public static void ConfigureHost(this RabbitMqTransportFactoryConfigurator configurator, Uri hostAddress,
Action <ConnectionFactoryConfigurator> configureHost)
{
var hostConfigurator = new ConnectionFactoryConfiguratorImpl(RabbitMqEndpointAddress.Parse(hostAddress));
configureHost(hostConfigurator);
configurator.AddConfigurator(hostConfigurator);
}
public Uri GetDestinationAddress(string exchangeName, Action <IExchangeConfigurator> configure = null)
{
var address = new RabbitMqEndpointAddress(_hostAddress, new Uri($"exchange:{exchangeName}"));
var sendSettings = new RabbitMqSendSettings(address);
configure?.Invoke(sendSettings);
return(sendSettings.GetSendAddress(_hostAddress));
}
public void Should_return_a_valid_address_for_an_exchange()
{
var hostAddress = new Uri("rabbitmq://localhost/test");
var address = new RabbitMqEndpointAddress(hostAddress, new Uri("exchange:input-queue"));
Uri uri = address;
Assert.That(uri, Is.EqualTo(new Uri("rabbitmq://localhost/test/input-queue")));
}
private void DeleteQueue(string addressUrl)
{
using (var channel = _connection.CreateModel())
{
var name = RabbitMqEndpointAddress.Parse(addressUrl).Name;
channel.QueueDelete(name);
channel.ExchangeDelete(name);
channel.Close(200, "ok");
}
}
public Uri GetDelayedExchangeDestinationAddress(Uri address)
{
var endpointAddress = new RabbitMqEndpointAddress(_hostAddress, address);
var delayedExchangeAddress = endpointAddress.GetDelayAddress();
var settings = new RabbitMqSendSettings(delayedExchangeAddress);
settings.BindToExchange(endpointAddress.Name);
return(settings.GetSendAddress(_hostAddress));
}
public void Should_return_a_valid_address_with_a_secure_port()
{
var hostAddress = new Uri("rabbitmq://localhost/test");
var address = new RabbitMqEndpointAddress(hostAddress, new Uri("rabbitmqs://remote-host/input-queue"));
Assert.That(address.Port, Is.EqualTo(5671));
Uri uri = address;
Assert.That(uri, Is.EqualTo(new Uri("rabbitmqs://remote-host/input-queue")));
}
public Uri GetDestinationAddress(Type messageType, Action <IExchangeConfigurator> configure = null)
{
var exchangeName = _messageNameFormatter.GetMessageName(messageType).ToString();
var isTemporary = TypeMetadataCache.IsTemporaryMessageType(messageType);
var address = new RabbitMqEndpointAddress(_hostAddress, new Uri($"exchange:{exchangeName}?temporary={isTemporary}"));
var settings = new RabbitMqSendSettings(address);
configure?.Invoke(settings);
return(settings.GetSendAddress(_hostAddress));
}
public void Should_return_a_valid_address_for_a_full_address_with_encoded_slash()
{
var hostAddress = new Uri("rabbitmq://localhost/test");
var address = new RabbitMqEndpointAddress(hostAddress, new Uri("rabbitmq://remote-host/production%2Fclient/input-queue"));
Assert.That(address.VirtualHost, Is.EqualTo("production/client"));
Assert.That(address.Name, Is.EqualTo("input-queue"));
Uri uri = address;
Assert.That(uri, Is.EqualTo(new Uri("rabbitmq://remote-host/production%2Fclient/input-queue")));
}
async Task <ISendTransport> ISendTransportProvider.GetSendTransport(Uri address)
{
async Task <CachedSendTransport> Create(Uri transportAddress)
{
var endpointAddress = new RabbitMqEndpointAddress(_host.Address, address);
var transport = await _host.CreateSendTransport(endpointAddress, _modelContextSupervisor);
return(new CachedSendTransport(transportAddress, transport));
}
return(await _index.Get(address, Create).ConfigureAwait(false));
}
public void Should_return_a_valid_address_for_a_full_address_using_default_virtual_host()
{
var hostAddress = new Uri("rabbitmq://localhost/test");
var address = new RabbitMqEndpointAddress(hostAddress, new Uri("rabbitmq://remote-host/input-queue"));
Assert.That(address.VirtualHost, Is.EqualTo("/"));
Assert.That(address.Name, Is.EqualTo("input-queue"));
Assert.That(address.Port, Is.EqualTo(5672));
Uri uri = address;
Assert.That(uri, Is.EqualTo(new Uri("rabbitmq://remote-host/input-queue")));
}
public bool Start(HostControl hostControl)
{
_hostControl = hostControl;
_log.InfoFormat("RabbitMQ Ingest Stress Test (using MassTransit)");
_log.InfoFormat("Host: {0}", _serviceBusUri);
_log.InfoFormat("Username: {0}", _username);
_log.InfoFormat("Password: {0}", new String('*', _password.Length));
_log.InfoFormat("Message Size: {0} {1}", _messageSize, _mixed ? "(mixed)" : "(fixed)");
_log.InfoFormat("Iterations: {0}", _iterations);
_log.InfoFormat("Clients: {0}", _instances);
_log.InfoFormat("Heartbeat: {0}", _heartbeat);
_log.InfoFormat("Creating {0}", _serviceBusUri);
IServiceBus serviceBus = ServiceBusFactory.New(x =>
{
x.UseRabbitMq(r =>
{
r.ConfigureHost(_serviceBusUri, h =>
{
h.SetUsername(_username);
h.SetPassword(_password);
h.SetRequestedHeartbeat(_heartbeat);
});
});
x.ReceiveFrom(_serviceBusUri);
x.SetConcurrentConsumerLimit(_consumerLimit);
x.Subscribe(s => s.Handler <StressfulRequest>((context, message) =>
{
// just respond with the Id
context.Respond(new StressfulResponseMessage(message.RequestId));
}));
});
_serviceBusAddress = serviceBus.Endpoint.Address as RabbitMqEndpointAddress;
serviceBus.Dispose();
// this just ensures the queues are setup right
_generatorStartTime = Stopwatch.StartNew();
StartStressGenerators().Wait(_cancel.Token);
return(true);
}
public Task <ISendTransport> CreateSendTransport(RabbitMqEndpointAddress address, IModelContextSupervisor modelContextSupervisor)
{
TransportLogMessages.CreateSendTransport(address);
var settings = _hostTopology.SendTopology.GetSendSettings(address);
var brokerTopology = settings.GetBrokerTopology();
IPipe <ModelContext> pipe = new ConfigureTopologyFilter <SendSettings>(settings, brokerTopology).ToPipe();
var supervisor = new ModelContextSupervisor(modelContextSupervisor);
var transport = CreateSendTransport(supervisor, pipe, settings.ExchangeName);
return(Task.FromResult(transport));
}
public Task <ISendTransport> CreateSendTransport(IModelContextSupervisor modelContextSupervisor, Uri address)
{
LogContext.SetCurrentIfNull(_hostConfiguration.LogContext);
var endpointAddress = new RabbitMqEndpointAddress(_hostConfiguration.HostAddress, address);
TransportLogMessages.CreateSendTransport(endpointAddress);
var settings = _topologyConfiguration.Send.GetSendSettings(endpointAddress);
var brokerTopology = settings.GetBrokerTopology();
IPipe <ModelContext> configureTopology = new ConfigureTopologyFilter <SendSettings>(settings, brokerTopology).ToPipe();
return(CreateSendTransport(modelContextSupervisor, configureTopology, settings.ExchangeName, endpointAddress));
}
private void BindQueue(string addressUrl)
{
using (var channel = _connection.CreateModel())
{
var name = RabbitMqEndpointAddress.Parse(addressUrl).Name;
var queue = channel.QueueDeclare(name, true, false, false, null);
//var args = new Dictionary<string, object> { { "x-expires", 15000 } };
//var queue = channel.QueueDeclare(name, true, false, false, args);
channel.ExchangeDeclare(name, ExchangeType.Fanout, true);
//channel.ExchangeDeclare(name, ExchangeType.Fanout, true, false, args);
channel.QueueBind(queue, name, "");
channel.Close(200, "ok");
}
}
public async Task <ISendTransport> CreateSendTransport(RabbitMqEndpointAddress address)
{
Task <CachedSendTransport> Create(Uri transportAddress)
{
var settings = _hostTopology.SendTopology.GetSendSettings(address);
var brokerTopology = settings.GetBrokerTopology();
var supervisor = CreateModelContextSupervisor();
IPipe <ModelContext> pipe = new ConfigureTopologyFilter <SendSettings>(settings, brokerTopology).ToPipe();
var transport = CreateSendTransport(supervisor, pipe, settings.ExchangeName);
return(Task.FromResult(new CachedSendTransport(transportAddress, transport)));
}
return(await _index.Get(address, Create).ConfigureAwait(false));
}
Task <ISendTransport> CreateSendTransport(IModelContextSupervisor modelContextSupervisor, IPipe <ModelContext> pipe, string exchangeName,
RabbitMqEndpointAddress endpointAddress)
{
var supervisor = new ModelContextSupervisor(modelContextSupervisor);
var delayedExchangeAddress = endpointAddress.GetDelayAddress();
var delaySettings = new RabbitMqDelaySettings(delayedExchangeAddress);
delaySettings.BindToExchange(exchangeName);
IPipe <ModelContext> delayPipe = new ConfigureTopologyFilter <DelaySettings>(delaySettings, delaySettings.GetBrokerTopology()).ToPipe();
var sendTransportContext = new SendTransportContext(_hostConfiguration, supervisor, pipe, exchangeName, delayPipe, delaySettings.ExchangeName);
var transport = new RabbitMqSendTransport(sendTransportContext);
modelContextSupervisor.AddSendAgent(transport);
return(Task.FromResult <ISendTransport>(transport));
}
void CleanUpQueuesAndExchanges()
{
RabbitMqEndpointAddress address = RabbitMqEndpointAddress.Parse(_serviceBusUri);
ConnectionFactory connectionFactory = address.ConnectionFactory;
if (string.IsNullOrWhiteSpace(connectionFactory.UserName))
{
connectionFactory.UserName = "******";
}
if (string.IsNullOrWhiteSpace(connectionFactory.Password))
{
connectionFactory.Password = "******";
}
using (IConnection connection = connectionFactory.CreateConnection())
{
using (IModel model = connection.CreateModel())
{
model.ExchangeDelete(address.Name);
model.QueueDelete(address.Name);
for (int i = 0; i < 10000; i++)
{
string name = string.Format("{0}_client_{1}", address.Name, i);
try
{
model.QueueDeclarePassive(name);
}
catch (OperationInterruptedException)
{
break;
}
model.ExchangeDelete(name);
model.QueueDelete(name);
}
}
}
}
public RabbitMqDelaySettings(RabbitMqEndpointAddress address)
: base(address)
{
}
public void WhenParsed()
{
_addr = RabbitMqEndpointAddress.Parse(Uri);
}
public void TheQueue()
{
_addr = RabbitMqEndpointAddress.Parse(Uri);
}
Task StartStressGenerator(int instance, Task start)
{
var ready = new TaskCompletionSource <bool>();
var composer = new TaskComposer <bool>(_cancel.Token, false);
var endpointAddress = _serviceBus.Endpoint.Address as IRabbitMqEndpointAddress;
string queueName = string.Format("{0}_client_{1}", endpointAddress.Name, instance);
Uri uri = RabbitMqEndpointAddress.Parse(_clientUri).ForQueue(queueName).Uri;
var uriBuilder = new UriBuilder(uri);
uriBuilder.Query = _clientUri.Query.Trim('?');
Uri address = uriBuilder.Uri;
composer.Execute(() => { Interlocked.Increment(ref _instanceCount); });
IServiceBus bus = null;
composer.Execute(() =>
{
_log.InfoFormat("Creating {0}", address);
bus = ServiceBusFactory.New(x =>
{
x.UseRabbitMq(r =>
{
r.ConfigureHost(address, h =>
{
h.SetUsername(_username);
h.SetPassword(_password);
h.SetRequestedHeartbeat(_heartbeat);
});
});
x.ReceiveFrom(address);
});
}, false);
Stopwatch clientTimer = null;
composer.Execute(() =>
{
ready.TrySetResult(true);
return(start);
});
composer.Execute(() => clientTimer = Stopwatch.StartNew());
for (int requestClient = 0; requestClient < _requestsPerInstance; requestClient++)
{
int clientIndex = requestClient;
composer.Execute(() =>
{
Task task = composer.Compose(x =>
{
for (int i = 0; i < _iterations; i++)
{
int iteration = i;
x.Execute(() =>
{
string messageContent = _mixed && iteration % 2 == 0
? new string('*', 128)
: _messageContent;
var requestMessage = new StressfulRequestMessage(messageContent);
ITaskRequest <StressfulRequest> taskRequest =
bus.PublishRequestAsync <StressfulRequest>(requestMessage, r =>
{
r.Handle <StressfulResponse>(response =>
{
Interlocked.Increment(ref _responseCount);
TimeSpan timeSpan = response.Timestamp - requestMessage.Timestamp;
Interlocked.Add(ref _responseTime, (long)timeSpan.TotalMilliseconds);
_timings[instance][clientIndex * _iterations + iteration] = (int)timeSpan.TotalMilliseconds;
if (response.RequestId != requestMessage.RequestId)
{
Interlocked.Increment(ref _mismatchedResponseCount);
}
});
});
Interlocked.Increment(ref _requestCount);
return(taskRequest.Task);
});
}
});
return(task);
});
}
composer.Execute(() => clientTimer.Stop());
composer.Execute(() => bus.Dispose(), false);
composer.Compensate(compensation => { return(compensation.Handled()); });
composer.Finally(status =>
{
Interlocked.Add(ref _totalTime, clientTimer.ElapsedMilliseconds);
int count = Interlocked.Decrement(ref _instanceCount);
if (count == 0)
{
Task.Factory.StartNew(() => _hostControl.Stop());
}
}, false);
_clientTasks.Add(composer.Finish());
return(ready.Task);
}
public SendSettings GetSendSettings(RabbitMqEndpointAddress address)
{
return(new RabbitMqSendSettings(address));
}
Task <ISendTransport> ISendTransportProvider.GetSendTransport(Uri address)
{
var endpointAddress = new RabbitMqEndpointAddress(_host.Address, address);
return(_host.CreateSendTransport(endpointAddress));
}
public void TheQueue()
{
_addr = RabbitMqEndpointAddress.Parse(Uri);
}
Task StartStressGenerator(int instance, Task start)
{
var ready = new TaskCompletionSource <bool>();
var composer = new TaskComposer <bool>(_cancel.Token, false);
string queueName = string.Format("{0}_client_{1}", _serviceBusAddress.Name, instance);
Uri uri = RabbitMqEndpointAddress.Parse(_clientUri).ForQueue(queueName).Uri;
var uriBuilder = new UriBuilder(uri);
uriBuilder.Query = _clientUri.Query.Trim('?');
Uri address = uriBuilder.Uri;
composer.Execute(() => { Interlocked.Increment(ref _instanceCount); });
composer.Execute(async() => { await Task.Yield(); });
IServiceBus bus = null;
composer.Execute(() =>
{
_log.InfoFormat("Creating {0}", address);
bus = ServiceBusFactory.New(x =>
{
x.UseRabbitMq(r =>
{
r.ConfigureHost(address, h =>
{
h.SetUsername(_username);
h.SetPassword(_password);
h.SetRequestedHeartbeat(_heartbeat);
});
});
x.ReceiveFrom(address);
});
}, false);
Stopwatch clientTimer = null;
composer.Execute(async() =>
{
ready.TrySetResult(true);
await start;
});
composer.Execute(() => clientTimer = Stopwatch.StartNew());
composer.Execute(() =>
{
Task task = composer.Compose(x =>
{
for (int i = 0; i < _iterations; i++)
{
int iteration = i;
x.Execute(() =>
{
string messageContent = _mixed && iteration % 2 == 0
? new string('*', 128)
: _messageContent;
var requestMessage = new StressfulRequestMessage(messageContent);
Stopwatch sendTimer = Stopwatch.StartNew();
bus.Publish <StressfulRequest>(requestMessage);
sendTimer.Stop();
Interlocked.Add(ref _sendTime, sendTimer.ElapsedTicks);
_timings[instance][iteration] = (int)sendTimer.ElapsedTicks;
Interlocked.Increment(ref _sendCount);
});
}
});
return(task);
});
composer.Execute(() => clientTimer.Stop());
composer.Execute(() => bus.Dispose(), false);
composer.Compensate(compensation => { return(compensation.Handled()); });
composer.Finally(status =>
{
Interlocked.Add(ref _totalTime, clientTimer.ElapsedMilliseconds);
int count = Interlocked.Decrement(ref _instanceCount);
if (count == 0)
{
Task.Factory.StartNew(() => _hostControl.Stop());
}
}, false);
_clientTasks.Add(composer.Finish());
return(ready.Task);
}
public void WhenParsed()
{
_addr = RabbitMqEndpointAddress.Parse(Uri);
}
public bool Start(HostControl hostControl)
{
_hostControl = hostControl;
_log.InfoFormat("RabbitMQ Ingest Stress Test (using MassTransit)");
_log.InfoFormat("Host: {0}", _serviceBusUri);
_log.InfoFormat("Username: {0}", _username);
_log.InfoFormat("Password: {0}", new String('*', _password.Length));
_log.InfoFormat("Message Size: {0} {1}", _messageSize, _mixed ? "(mixed)" : "(fixed)");
_log.InfoFormat("Iterations: {0}", _iterations);
_log.InfoFormat("Clients: {0}", _instances);
_log.InfoFormat("Heartbeat: {0}", _heartbeat);
_log.InfoFormat("Creating {0}", _serviceBusUri);
IServiceBus serviceBus = ServiceBusFactory.New(x =>
{
x.UseRabbitMq(r =>
{
r.ConfigureHost(_serviceBusUri, h =>
{
h.SetUsername(_username);
h.SetPassword(_password);
h.SetRequestedHeartbeat(_heartbeat);
});
});
x.ReceiveFrom(_serviceBusUri);
x.SetConcurrentConsumerLimit(_consumerLimit);
x.Subscribe(s => s.Handler<StressfulRequest>((context, message) =>
{
// just respond with the Id
context.Respond(new StressfulResponseMessage(message.RequestId));
}));
});
_serviceBusAddress = serviceBus.Endpoint.Address as RabbitMqEndpointAddress;
serviceBus.Dispose();
// this just ensures the queues are setup right
_generatorStartTime = Stopwatch.StartNew();
StartStressGenerators().Wait(_cancel.Token);
return true;
}
