/// <summary>
/// RabbitConnectionPool shutdown method closes all connections and disposes them.
/// </summary>
public void Shutdown()
{
if (Monitor.TryEnter(_lockObj, TimeSpan.FromSeconds(_timeout)))
{
try
{
if (!_shutdown)
{
_shutdown = true;
foreach (var connection in _connectionPool)
{
try
{
connection.Close(200, $"CookedRabbit connection ({connection.ClientProvidedName}) shutting down.");
connection.Dispose();
}
catch { }
}
_connectionPool = new ConcurrentQueue <IConnection>();
_connectionFactory = null;
_seasoning = null;
}
}
finally { Monitor.Exit(_lockObj); }
}
}
public BenchmarkFixture()
{
QueueName = "CookedRabbit.Benchmark.Scaling";
ExchangeName = string.Empty;
// Configured for performance.
var seasoning = new RabbitSeasoning
{
ThrottleFastBodyLoops = false,
ThrowExceptions = false,
WriteErrorsToConsole = false,
WriteErrorsToILogger = false,
BatchBreakOnException = true
};
seasoning.PoolSettings.EnableAutoScaling = true;
seasoning.PoolSettings.EmptyPoolWaitTime = 10;
seasoning.PoolSettings.WriteSleepNoticeToConsole = false;
seasoning.PoolSettings.ConnectionPoolCount = 4;
seasoning.PoolSettings.ChannelPoolCount = 4;
var channelPool = new RabbitChannelPool();
channelPool.Initialize(seasoning).GetAwaiter().GetResult();
DeliveryService = new RabbitDeliveryService(seasoning, channelPool);
TopologyService = new RabbitTopologyService(seasoning, channelPool);
MaintenanceService = new RabbitMaintenanceService(seasoning, channelPool);
TopologyService.QueueDeclareAsync(QueueName).GetAwaiter().GetResult();
Payloads = CreatePayloadsAsync(MessagesToSend, MessageSize).GetAwaiter().GetResult();
}
// Setting up two Burrows in this demo code.
public static void SetupRabbitBurrows(RabbitSeasoning seasoning = null, ILogger logger = null)
{
if (_seasoning is null)
{
_seasoning = new RabbitSeasoning
{
ThrottleFastBodyLoops = false,
ThrowExceptions = false,
WriteErrorsToConsole = true
};
_seasoning.FactorySettings.UseUri = true;
_seasoning.FactorySettings.Uri = new Uri("amqp://*****:*****@localhost:5672/");
_seasoning.SerializeSettings.SerializationMethod = SerializationMethod.Utf8Json;
_seasoning.PoolSettings.EnableAutoScaling = true;
_seasoning.PoolSettings.ConnectionName = "RabbitBurrowAdvancedExamples";
_seasoning.PoolSettings.ConnectionPoolCount = 5;
_seasoning.PoolSettings.ChannelPoolCount = 25;
}
if (_burrow is null)
{
_logger = logger;
_burrow = new RabbitBurrow(_seasoning, _logger);
}
if (_burrowAsyncDispatch is null)
{
_seasoning.FactorySettings.EnableDispatchConsumersAsync = true;
_burrowAsyncDispatch = new RabbitBurrow(_seasoning, _logger);
}
}
public StandardFixture()
{
Seasoning = new RabbitSeasoning
{
ThrottleFastBodyLoops = false,
ThrowExceptions = false
};
Seasoning.SerializeSettings.SerializationMethod = SerializationMethod.Utf8Json;
Seasoning.FactorySettings.RabbitHostName = "localhost";
Seasoning.PoolSettings.EnableAutoScaling = true;
Seasoning.PoolSettings.ConnectionName = "RabbitServiceTest";
Seasoning.PoolSettings.ConnectionPoolCount = 5;
Seasoning.PoolSettings.ChannelPoolCount = 25;
Burrow = new RabbitBurrow(Seasoning);
try
{
Burrow.Maintenance.QueueDeclareAsync(TestQueueName1).GetAwaiter().GetResult();
Burrow.Maintenance.QueueDeclareAsync(TestQueueName2).GetAwaiter().GetResult();
Burrow.Maintenance.QueueDeclareAsync(TestQueueName3).GetAwaiter().GetResult();
Burrow.Maintenance.QueueDeclareAsync(TestQueueName4).GetAwaiter().GetResult();
Burrow.Maintenance.ExchangeDeclareAsync(TestExchangeName, ExchangeType.Fanout.Description()).GetAwaiter().GetResult();
}
catch { }
}
/// <summary>
/// CookedRabbit RabbitMaintenanceService constructor. Allows for the sharing of a channel pool. If channel pool is not initialized, it will automatically initialize in here.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <param name="rcp"></param>
/// <param name="logger"></param>
public RabbitMaintenanceService(RabbitSeasoning rabbitSeasoning, IRabbitChannelPool rcp, ILogger logger = null) : base(rabbitSeasoning, rcp, logger)
{
Guard.AgainstNull(rabbitSeasoning, nameof(rabbitSeasoning));
Guard.AgainstNull(rcp, nameof(rcp));
_logger = logger;
_seasoning = rabbitSeasoning;
_rcp = rcp;
if (!_rcp.IsInitialized)
{
_rcp.Initialize(rabbitSeasoning).GetAwaiter().GetResult();
}
if (_seasoning.MaintenanceSettings.EnablePingPong)
{
_pingPong = PingPongAsync($"{_seasoning.MaintenanceSettings.PingPongQueueName}.{RandomString(5, 10)}", _cancellationTokenSource.Token);
}
if (_seasoning.MaintenanceSettings.ApiSettings.RabbitApiAccessEnabled)
{
var credentials = new NetworkCredential(
_seasoning.MaintenanceSettings.ApiSettings.RabbitApiUserName,
_seasoning.MaintenanceSettings.ApiSettings.RabbitApiUserPassword);
_httpClient = CreateHttpClient(credentials, TimeSpan.FromSeconds(_seasoning.MaintenanceSettings.ApiSettings.RabbitApiTimeout));
}
}
/// <summary>
/// CookedRabbit RabbitChannelPool factory.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <returns><see cref="IRabbitChannelPool"/></returns>
public static async Task <IRabbitChannelPool> CreateRabbitChannelPoolAsync(RabbitSeasoning rabbitSeasoning)
{
var rcp = new RabbitChannelPool();
await rcp.Initialize(rabbitSeasoning).ConfigureAwait(false);
return(rcp);
}
// RabbitBurrow Factory
public static RabbitBurrow GetOrCreateRabbitBurrow(RabbitSeasoning seasoning = null, ILogger logger = null)
{
if (_burrow is null)
{
_logger = logger;
if (_seasoning is null)
{
_seasoning = new RabbitSeasoning
{
ThrottleFastBodyLoops = false,
ThrowExceptions = false,
WriteErrorsToConsole = true
};
_seasoning.FactorySettings.UseUri = true;
_seasoning.FactorySettings.Uri = new Uri("amqp://*****:*****@localhost:5672/");
_seasoning.SerializeSettings.SerializationMethod = SerializationMethod.Utf8Json;
_seasoning.PoolSettings.EnableAutoScaling = true;
_seasoning.PoolSettings.ConnectionName = "RabbitBurrowExamples";
_seasoning.PoolSettings.ConnectionPoolCount = 5;
_seasoning.PoolSettings.ChannelPoolCount = 25;
}
_burrow = new RabbitBurrow(_seasoning, _logger);
}
return(_burrow);
}
/// <summary>
/// CookedRabbit RabbitChannelPool factory.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <returns><see cref="IRabbitChannelPool"/></returns>
public static async Task <IRabbitChannelPool> CreateRabbitChannelPoolAsync(RabbitSeasoning rabbitSeasoning)
{
RabbitChannelPool rcp = new RabbitChannelPool();
await rcp.Initialize(rabbitSeasoning);
return(rcp);
}
private async Task Setup(int messagesToSend, int messageSizes)
{
QueueName = "CookedRabbit.Benchmark.Scaling";
ExchangeName = string.Empty;
// Configured for performance.
var seasoning = new RabbitSeasoning
{
ThrottleFastBodyLoops = false,
ThrowExceptions = false,
WriteErrorsToConsole = false,
WriteErrorsToILogger = false,
BatchBreakOnException = true
};
seasoning.PoolSettings.EnableAutoScaling = true;
seasoning.PoolSettings.EmptyPoolWaitTime = 10;
seasoning.PoolSettings.WriteSleepNoticeToConsole = false;
seasoning.PoolSettings.ConnectionPoolCount = 4;
seasoning.PoolSettings.ChannelPoolCount = 16;
var channelPool = new RabbitChannelPool();
await channelPool.Initialize(seasoning);
_deliveryService = new RabbitDeliveryService(seasoning, channelPool);
_topologyService = new RabbitTopologyService(seasoning, channelPool);
_maintenanceService = new RabbitMaintenanceService(seasoning, channelPool);
await _topologyService.QueueDeclareAsync(QueueName);
Payloads = await CreatePayloadsAsync(messagesToSend, messageSizes);
FirstRun = false;
}
/// <summary>
/// CookedRabbit RabbitTopologyService constructor. Allows for the sharing of a channel pool and connection pool.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <param name="rchanp"></param>
/// <param name="rconp"></param>
/// <param name="logger"></param>
public RabbitMaintenanceService(RabbitSeasoning rabbitSeasoning,
IRabbitChannelPool rchanp,
IRabbitConnectionPool rconp,
ILogger logger = null) : base(rabbitSeasoning, rchanp, rconp, logger)
{
Guard.AgainstNull(rabbitSeasoning, nameof(rabbitSeasoning));
Guard.AgainstNull(rchanp, nameof(rchanp));
Guard.AgainstNull(rconp, nameof(rconp));
_logger = logger;
_seasoning = rabbitSeasoning;
rchanp.SetConnectionPoolAsync(rabbitSeasoning, rconp).GetAwaiter().GetResult();
RabbitChannelPool = rchanp;
if (_seasoning.MaintenanceSettings.EnablePingPong)
{
PingPong = PingPongAsync($"{_seasoning.MaintenanceSettings.PingPongQueueName}", _cancellationTokenSource.Token);
}
if (_seasoning.MaintenanceSettings.ApiSettings.RabbitApiAccessEnabled)
{
var credentials = new NetworkCredential(
_seasoning.MaintenanceSettings.ApiSettings.RabbitApiUserName,
_seasoning.MaintenanceSettings.ApiSettings.RabbitApiUserPassword);
_httpClient = GetOrCreateHttpClient(credentials, TimeSpan.FromSeconds(_seasoning.MaintenanceSettings.ApiSettings.RabbitApiTimeout));
}
}
public IntegrationFixture_Zero()
{
Seasoning = new RabbitSeasoning
{
ThrottleFastBodyLoops = false,
ThrowExceptions = false
};
Seasoning.SerializeSettings.SerializationMethod = SerializationMethod.ZeroFormat;
Seasoning.FactorySettings.RabbitHostName = "localhost";
Seasoning.PoolSettings.EnableAutoScaling = true;
Seasoning.PoolSettings.ConnectionName = "RabbitServiceTest";
Seasoning.PoolSettings.ConnectionPoolCount = 1;
Seasoning.PoolSettings.ChannelPoolCount = 2;
var channelPool = new RabbitChannelPool();
channelPool
.SetConnectionPoolAsync(Seasoning, new RabbitConnectionPool())
.GetAwaiter().GetResult();
RabbitDeliveryService = new RabbitDeliveryService(Seasoning, channelPool);
RabbitTopologyService = new RabbitTopologyService(Seasoning, channelPool);
RabbitSerializeService = new RabbitSerializeService(Seasoning, channelPool);
try
{
RabbitTopologyService.QueueDeleteAsync(TestQueueName1, false, false).GetAwaiter().GetResult();
RabbitTopologyService.QueueDeleteAsync(TestQueueName2, false, false).GetAwaiter().GetResult();
RabbitTopologyService.QueueDeleteAsync(TestQueueName3, false, false).GetAwaiter().GetResult();
RabbitTopologyService.QueueDeleteAsync(TestQueueName4, false, false).GetAwaiter().GetResult();
RabbitTopologyService.ExchangeDeleteAsync(TestExchangeName, false).GetAwaiter().GetResult();
}
catch { }
}
/// <summary>
/// CookedRabbit RabbitTopologyService constructor.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <param name="logger"></param>
public RabbitTopologyService(RabbitSeasoning rabbitSeasoning, ILogger logger = null)
{
Guard.AgainstNull(rabbitSeasoning, nameof(rabbitSeasoning));
_logger = logger;
_seasoning = rabbitSeasoning;
RabbitChannelPool = Factories.CreateRabbitChannelPoolAsync(rabbitSeasoning).GetAwaiter().GetResult();
}
/// <summary>
/// CookedRabbit RabbitSerializeService constructor.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <param name="logger"></param>
public RabbitSerializeService(RabbitSeasoning rabbitSeasoning, ILogger logger = null) : base(rabbitSeasoning, logger)
{
Guard.AgainstNull(rabbitSeasoning, nameof(rabbitSeasoning));
_logger = logger;
_seasoning = rabbitSeasoning;
_rcp = Factories.CreateRabbitChannelPoolAsync(rabbitSeasoning).GetAwaiter().GetResult();
}
/// <summary>
/// CookedRabbit RabbitTopologyService constructor. Allows for the sharing of a channel pool and connection pool.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <param name="rchanp"></param>
/// <param name="rconp"></param>
/// <param name="logger"></param>
public RabbitTopologyService(RabbitSeasoning rabbitSeasoning, IRabbitChannelPool rchanp, IRabbitConnectionPool rconp, ILogger logger = null)
{
_logger = logger;
_seasoning = rabbitSeasoning;
rchanp.SetConnectionPoolAsync(rabbitSeasoning, rconp).GetAwaiter().GetResult();
_rcp = rchanp;
}
/// <summary>
/// CookedRabbit RabbitTopologyService constructor. Allows for the sharing of a channel pool. If channel is not initialized, it will automatically initialize in here.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <param name="rcp"></param>
/// <param name="logger"></param>
public RabbitTopologyService(RabbitSeasoning rabbitSeasoning, IRabbitChannelPool rcp, ILogger logger = null)
{
_logger = logger;
_seasoning = rabbitSeasoning;
_rcp = rcp;
if (!_rcp.IsInitialized)
{
_rcp.Initialize(rabbitSeasoning).GetAwaiter().GetResult();
}
}
/// <summary>
/// CookedRabbit RabbitSerializeService constructor. Allows for the sharing of a channel pool and connection pool.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <param name="rchanp"></param>
/// <param name="rconp"></param>
/// <param name="logger"></param>
public RabbitSerializeService(RabbitSeasoning rabbitSeasoning, IRabbitChannelPool rchanp, IRabbitConnectionPool rconp, ILogger logger = null) : base(rabbitSeasoning, rchanp, rconp, logger)
{
Guard.AgainstNull(rabbitSeasoning, nameof(rabbitSeasoning));
Guard.AgainstNull(rchanp, nameof(rchanp));
Guard.AgainstNull(rconp, nameof(rconp));
_logger = logger;
_seasoning = rabbitSeasoning;
rchanp.SetConnectionPoolAsync(rabbitSeasoning, rconp).GetAwaiter().GetResult();
_rcp = rchanp;
}
public async Task PublishInParallelAsync()
{
QueueName = "CookedRabbit.Benchmark";
// Configured for performance.
var seasoning = new RabbitSeasoning
{
ThrottleFastBodyLoops = false,
ThrowExceptions = false,
WriteErrorsToConsole = false,
WriteErrorsToILogger = false,
BatchBreakOnException = true
};
seasoning.PoolSettings.EnableAutoScaling = true;
seasoning.PoolSettings.EmptyPoolWaitTime = 0;
seasoning.PoolSettings.WriteSleepNoticeToConsole = false;
seasoning.PoolSettings.ConnectionPoolCount = 8;
seasoning.PoolSettings.ChannelPoolCount = 32;
var channelPool = await Factories.CreateRabbitChannelPoolAsync(seasoning).ConfigureAwait(false);
_deliveryService = new RabbitDeliveryService(seasoning, channelPool);
_topologyService = new RabbitTopologyService(seasoning, channelPool);
_maintenanceService = new RabbitMaintenanceService(seasoning, channelPool);
var queueNames = new List <string>
{
$"{QueueName}.Scaling_00",
$"{QueueName}.Scaling_01",
$"{QueueName}.Scaling_02",
$"{QueueName}.Scaling_03",
$"{QueueName}.Scaling_04",
$"{QueueName}.Scaling_05",
$"{QueueName}.Scaling_06",
$"{QueueName}.Scaling_07",
$"{QueueName}.Scaling_08",
$"{QueueName}.Scaling_09",
};
var envelopes = await CreateEnvelopesAsync(queueNames, MessagesToSend, MessageSizes).ConfigureAwait(false);
foreach (string queueName in queueNames)
{
await _topologyService.QueueDeclareAsync(queueName).ConfigureAwait(false);
await _maintenanceService.PurgeQueueAsync(queueName).ConfigureAwait(false);
}
await _deliveryService.PublishInParallelAsync(envelopes).ConfigureAwait(false);
}
/// <summary>
/// CookedRabbit RabbitSerializeService constructor. Allows for the sharing of a channel pool. If channel pool is not initialized, it will automatically initialize in here.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <param name="rcp"></param>
/// <param name="logger"></param>
public RabbitSerializeService(RabbitSeasoning rabbitSeasoning, IRabbitChannelPool rcp, ILogger logger = null) : base(rabbitSeasoning, rcp, logger)
{
Guard.AgainstNull(rabbitSeasoning, nameof(rabbitSeasoning));
Guard.AgainstNull(rcp, nameof(rcp));
_logger = logger;
_seasoning = rabbitSeasoning;
_rcp = rcp;
if (!_rcp.IsInitialized)
{
_rcp.Initialize(rabbitSeasoning).GetAwaiter().GetResult();
}
}
/// <summary>
/// CookedRabbit RabbitTopologyService constructor. Allows for the sharing of a channel pool. If channel pool is not initialized, it will automatically initialize in here.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <param name="rcp"></param>
/// <param name="logger"></param>
public RabbitTopologyService(RabbitSeasoning rabbitSeasoning, IRabbitChannelPool rcp, ILogger logger = null)
{
Guard.AgainstNull(rabbitSeasoning, nameof(rabbitSeasoning));
Guard.AgainstNull(rcp, nameof(rcp));
_logger = logger;
_seasoning = rabbitSeasoning;
RabbitChannelPool = rcp;
if (!RabbitChannelPool.IsInitialized)
{
RabbitChannelPool.Initialize(rabbitSeasoning).GetAwaiter().GetResult();
}
}
public void Setup()
{
// Configured for performance.
var seasoning = new RabbitSeasoning
{
ThrottleFastBodyLoops = false,
ThrowExceptions = false,
WriteErrorsToConsole = false,
WriteErrorsToILogger = false,
};
seasoning.PoolSettings.EnableAutoScaling = true;
seasoning.PoolSettings.EmptyPoolWaitTime = 10;
seasoning.PoolSettings.WriteSleepNoticeToConsole = false;
seasoning.PoolSettings.ConnectionPoolCount = 4;
seasoning.PoolSettings.ChannelPoolCount = 16;
var channelPool = new RabbitChannelPool();
channelPool.Initialize(seasoning).GetAwaiter().GetResult();
_deliveryService = new RabbitDeliveryService(seasoning, channelPool);
_topologyService = new RabbitTopologyService(seasoning, channelPool);
}
/// <summary>
/// Initializes the RabbitConnectionPool for use.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <returns></returns>
public async Task Initialize(RabbitSeasoning rabbitSeasoning)
{
_shutdown = false;
_seasoning = rabbitSeasoning;
if (_connectionFactory is null)
{
_connectionFactory = await CreateConnectionFactoryAsync().ConfigureAwait(false);
if (_connectionFactory is null)
{
throw new ArgumentNullException("Connection factory is null.");
}
}
if (!IsInitialized)
{
_connectionsToMaintain = _seasoning.PoolSettings.ConnectionPoolCount;
await CreateConnectionsAsync(_seasoning.PoolSettings.ConnectionName).ConfigureAwait(false);
IsInitialized = true;
}
}
public static async Task PublishInParallelAsync()
{
// Configured for performance.
var seasoning = new RabbitSeasoning
{
ThrottleFastBodyLoops = false,
ThrowExceptions = false,
WriteErrorsToConsole = false,
WriteErrorsToILogger = false,
BatchBreakOnException = true
};
seasoning.PoolSettings.EnableAutoScaling = true;
seasoning.PoolSettings.EmptyPoolWaitTime = 0;
seasoning.PoolSettings.WriteSleepNoticeToConsole = false;
seasoning.PoolSettings.ConnectionPoolCount = 10;
seasoning.PoolSettings.ChannelPoolCount = 40;
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Creating RabbitChannelPool and RabbitServices...").ConfigureAwait(false);
var sw = Stopwatch.StartNew();
var channelPool = await Factories.CreateRabbitChannelPoolAsync(seasoning).ConfigureAwait(false);
var deliveryService = new RabbitDeliveryService(seasoning, channelPool);
var topologyService = new RabbitTopologyService(seasoning, channelPool);
var maintenanceService = new RabbitMaintenanceService(seasoning, channelPool);
sw.Stop();
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Creating RabbitChannelPool and RabbitServices finished. Time: {sw.ElapsedMilliseconds} ms").ConfigureAwait(false);
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Creating test data...").ConfigureAwait(false);
sw.Reset();
sw.Start();
var queueNames = new List <string>
{
$"{QueueName}.Scaling_00",
$"{QueueName}.Scaling_01",
$"{QueueName}.Scaling_02",
$"{QueueName}.Scaling_03",
$"{QueueName}.Scaling_04",
$"{QueueName}.Scaling_05",
$"{QueueName}.Scaling_06",
$"{QueueName}.Scaling_07",
$"{QueueName}.Scaling_08",
$"{QueueName}.Scaling_09",
};
var envelopes = await CreateEnvelopesAsync(queueNames, MessagesToSend, MessageSizes).ConfigureAwait(false);
sw.Stop();
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Creating test data finished. Time: {sw.ElapsedMilliseconds} ms").ConfigureAwait(false);
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Creating and/or Purging benchmark queues...").ConfigureAwait(false);
sw.Reset();
sw.Start();
foreach (string queueName in queueNames)
{
await topologyService.QueueDeclareAsync(queueName).ConfigureAwait(false);
await maintenanceService.PurgeQueueAsync(queueName).ConfigureAwait(false);
}
sw.Stop();
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Creating and/or Purging finished. Time: {sw.ElapsedMilliseconds} ms").ConfigureAwait(false);
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Publish test starting...").ConfigureAwait(false);
sw.Reset();
sw.Start();
await deliveryService.PublishInParallelAsync(envelopes).ConfigureAwait(false);
sw.Stop();
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Publish finished. Time: {sw.ElapsedMilliseconds} ms").ConfigureAwait(false);
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Publish rate {(MessagesToSend/1.0 / (sw.ElapsedMilliseconds / 1000.0)).ToString("0.###")} msg/s").ConfigureAwait(false);
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Purging benchmark queues...").ConfigureAwait(false);
sw.Reset();
sw.Start();
foreach (string queueName in queueNames)
{
await topologyService.QueueDeclareAsync(queueName).ConfigureAwait(false);
await maintenanceService.PurgeQueueAsync(queueName).ConfigureAwait(false);
}
sw.Stop();
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Purging finished. Time: {sw.ElapsedMilliseconds} ms").ConfigureAwait(false);
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Shutting down/disposing of services...").ConfigureAwait(false);
sw.Reset();
sw.Start();
deliveryService.Dispose();
topologyService.Dispose();
maintenanceService.Dispose();
sw.Stop();
await Console.Out.WriteLineAsync($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}: Shutting down/disposing of services finished. Time: {sw.ElapsedMilliseconds} ms").ConfigureAwait(false);
}
/// <summary>
/// CookedRabbit RabbitTopologyService constructor.
/// </summary>
/// <param name="rabbitSeasoning"></param>
/// <param name="logger"></param>
public RabbitTopologyService(RabbitSeasoning rabbitSeasoning, ILogger logger = null)
{
_logger = logger;
_seasoning = rabbitSeasoning;
_rcp = Factories.CreateRabbitChannelPoolAsync(rabbitSeasoning).GetAwaiter().GetResult();
}
