private async Task <ProducerResult> SendAsync(Messages <byte[]> messages)
{
IModel channel = null;
IChannelPool pool = null;
try
{
GenerateChannel(messages, ref channel, ref pool, out IBasicProperties props, out string exchage, out string routingKey);
// 发送消息
foreach (var item in messages.Body)
{
channel.BasicPublish(exchage, routingKey, props, item);
}
_logger.LogDebug($"RabbitMQ message [{exchage}-{routingKey}] has been published.");
return(ProducerResult.Success);
}
catch (Exception ex)
{
return(ExceptionReturn(await _serializer.SerializeMessageToStringAsync(messages), pool?.HostAddress, ex));
}
finally
{
Dispose(channel, pool);
}
}
public async Task <bool> PurgeQueueAsync(
IChannelPool channelPool,
string queueName,
bool deleteQueueAfter = false)
{
Guard.AgainstNull(channelPool, nameof(channelPool));
Guard.AgainstNullOrEmpty(queueName, nameof(queueName));
var error = false;
var channelHost = await channelPool.GetChannelAsync().ConfigureAwait(false);
try
{
channelHost.GetChannel().QueuePurge(queueName);
if (deleteQueueAfter)
{
channelHost.GetChannel().QueueDelete(queueName, false, false);
}
}
catch { error = true; }
finally
{
await channelPool
.ReturnChannelAsync(channelHost, error);
}
return(error);
}
public Publisher(IChannelPool channelPool, ReadOnlyMemory <byte> hashKey)
{
Guard.AgainstNull(channelPool, nameof(channelPool));
Config = channelPool.Config;
_logger = LogHelper.GetLogger <Publisher>();
if (Config.PublisherSettings.Encrypt && hashKey.Length != Utils.Constants.EncryptionKeySize)
{
_encrypt = false;
_logger.LogWarning("Encryption disabled, invalid hash key length ({0}) provided. Expected key length of {1}.", hashKey.Length, Utils.Constants.EncryptionKeySize);
}
else if (Config.PublisherSettings.Encrypt)
{
_encrypt = true;
_hashKey = hashKey;
}
_channelPool = channelPool;
_receiptBuffer = Channel.CreateUnbounded <PublishReceipt>(
new UnboundedChannelOptions
{
SingleWriter = false,
SingleReader = true,
});
_withHeaders = Config.PublisherSettings.WithHeaders;
_createPublishReceipts = Config.PublisherSettings.CreatePublishReceipts;
_compress = Config.PublisherSettings.Compress;
_waitForConfirmation = TimeSpan.FromMilliseconds(Config.PublisherSettings.WaitForConfirmationTimeoutInMilliseconds);
}
public Topologer(IChannelPool channelPool)
{
Guard.AgainstNull(channelPool, nameof(channelPool));
Options = channelPool.Options;
_channelPool = channelPool;
}
public async Task <bool> TransferMessageAsync(
IChannelPool channelPool,
string originQueueName,
string targetQueueName)
{
Guard.AgainstNull(channelPool, nameof(channelPool));
Guard.AgainstNullOrEmpty(originQueueName, nameof(originQueueName));
Guard.AgainstNullOrEmpty(targetQueueName, nameof(targetQueueName));
var error = false;
var channelHost = await channelPool.GetChannelAsync().ConfigureAwait(false);
var properties = channelHost.GetChannel().CreateBasicProperties();
properties.DeliveryMode = 2;
try
{
var result = channelHost.GetChannel().BasicGet(originQueueName, true);
if (result?.Body != null)
{
channelHost.GetChannel().BasicPublish(string.Empty, targetQueueName, false, properties, result.Body);
}
}
catch { error = true; }
finally
{
await channelPool
.ReturnChannelAsync(channelHost, error);
}
return(error);
}
public RabbitService(
IChannelPool chanPool,
ISerializationProvider serializationProvider,
IEncryptionProvider encryptionProvider = null,
ICompressionProvider compressionProvider = null,
ILoggerFactory loggerFactory = null,
Func <IPublishReceipt, ValueTask> processReceiptAsync = null)
{
Guard.AgainstNull(chanPool, nameof(chanPool));
Guard.AgainstNull(serializationProvider, nameof(serializationProvider));
LogHelper.LoggerFactory = loggerFactory;
Options = chanPool.Options;
ChannelPool = chanPool;
SerializationProvider = serializationProvider;
EncryptionProvider = encryptionProvider;
CompressionProvider = compressionProvider;
Publisher = new Publisher(ChannelPool, SerializationProvider, EncryptionProvider, CompressionProvider);
Topologer = new Topologer(ChannelPool);
Options.ApplyGlobalConsumerOptions();
BuildConsumers();
Publisher.StartAutoPublish(processReceiptAsync);
BuildConsumerTopologyAsync()
.GetAwaiter()
.GetResult();
}
public RabbitMQSubscribeMiddleware(
IChannelPool channelPool,
IRabbitMqSerializer serializer)
{
this.serializer = serializer;
this.channelPool = channelPool;
ChannelAccessor = channelPool.Acquire(ChannelQueueName, ConnectionName);
QueueDeclareConfiguration QueueConfiguration = new QueueDeclareConfiguration(ChannelQueueName);
QueueConfiguration.Declare(ChannelAccessor.Channel);
var properties = ChannelAccessor.Channel.CreateBasicProperties();
properties.Persistent = true;
Consumer = new EventingBasicConsumer(ChannelAccessor.Channel);
Consumer.Received += (model, ea) =>
{
var body = ea.Body.ToArray();
string message = (string)serializer.Deserialize(ea.Body.ToArray(), typeof(string));
Console.WriteLine(" [Subscribe] Received {0}", string.Format(message, DateTime.Now));
ChannelAccessor.Channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
};
ChannelAccessor.Channel.BasicConsume(
queue: QueueConfiguration.QueueName,
autoAck: false,
consumer: Consumer
);
}
public Topologer(Config config)
{
Guard.AgainstNull(config, nameof(config));
Config = config;
_channelPool = new ChannelPool(Config);
}
public RabbitMqDistributedEventBus(
IConsumerFactory consumerFactory,
IRabbitMqSerializer serializer,
IEventBusSubscriptionsManager subscriptionsManager,
IServiceProvider serviceProvider,
IChannelPool channelPool,
IOptions <EventBusOptions> eventBusOptions,
IOptions <RabbitMqEventBusOptions> rabbitMOptions)
: base(subscriptionsManager, serviceProvider, eventBusOptions)
{
RabbitMqOptions = rabbitMOptions.Value;
ConsumerFactory = consumerFactory;
Serializer = serializer;
ChannelPool = channelPool;
ChannelAccessor = ChannelPool.Acquire();
Consumer = ConsumerFactory.Create(
new ExchangeDeclareConfiguration(
RabbitMqOptions.Exchange,
type: "direct",
durable: true),
new QueueDeclareConfiguration(
RabbitMqOptions.QueueName,
durable: true,
exclusive: false,
autoDelete: false),
RabbitMqOptions.ConnectionName
);
Consumer.OnMessageReceived(ProcessEventAsync);
_subsManager.OnEventRemoved += SubsManager_OnEventRemoved;
}
public Topologer(IChannelPool channelPool)
{
Guard.AgainstNull(channelPool, nameof(channelPool));
Config = channelPool.Config;
_channelPool = channelPool;
}
public RabbitMQPublishMiddleware(
IChannelPool channelPool,
IRabbitMqSerializer serializer)
{
this.serializer = serializer;
this.channelPool = channelPool;
ChannelAccessor = channelPool.Acquire(ChannelQueueName, ConnectionName);
}
public bool TryGetValue(string name, out IChannelPool value)
{
if (!_pools.TryGetValue(name, out value))
{
throw new ChannelPoolNotFoundException(name);
}
return(true);
}
public Consumer(IChannelPool channelPool, string consumerName)
: this(
channelPool,
channelPool.Options.GetConsumerOptions(consumerName))
{
Guard.AgainstNull(channelPool, nameof(channelPool));
Guard.AgainstNullOrEmpty(consumerName, nameof(consumerName));
}
public Publisher(IChannelPool channelPool)
{
Guard.AgainstNull(channelPool, nameof(channelPool));
_logger = LogHelper.GetLogger <Publisher>();
_channelPool = channelPool;
Config = channelPool.Config;
ReceiptBuffer = Channel.CreateUnbounded <PublishReceipt>();
}
public Publisher(Config config)
{
Guard.AgainstNull(config, nameof(config));
_logger = LogHelper.GetLogger <Publisher>();
_channelPool = new ChannelPool(Config);
Config = config;
ReceiptBuffer = Channel.CreateUnbounded <PublishReceipt>();
}
public ConsumerTests(ITestOutputHelper output)
{
this.output = output;
config = ConfigReader.ConfigFileReadAsync("TestConfig.json").GetAwaiter().GetResult();
channelPool = new ChannelPool(config);
topologer = new Topologer(config);
rabbitService = new RabbitService("Config.json", null, null, null, null);
}
public RabbitMqDistributedEventBus(
IOptions <RabbitMqDistributedEventBusOptions> options,
IChannelPool channelPool,
IRabbitMqSerializer serializer)
{
ChannelPool = channelPool;
Serializer = serializer;
Options = options.Value;
}
public EventSubscriber(
IChannelPool channelPool,
HandlersStorage handlersStorage,
MiddlewaresStorage middlewaresStorage,
IServiceScopeFactory serviceScopeFactory,
ILogger <EventSubscriber> logger) : base(channelPool, handlersStorage, middlewaresStorage, serviceScopeFactory)
{
_logger = logger;
}
public AutoPublisher(IChannelPool channelPool, bool withHeaders = true)
{
Guard.AgainstNull(channelPool, nameof(channelPool));
_logger = LogHelper.GetLogger <AutoPublisher>();
Config = channelPool.Config;
Publisher = new Publisher(channelPool);
_withHeaders = withHeaders;
}
public ConsumerTests(ITestOutputHelper output)
{
this.output = output;
options = JsonFileReader.ReadFileAsync <Options>("TestConfig.json").GetAwaiter().GetResult();
channelPool = new ChannelPool(options);
topologer = new Topologer(options);
rabbitService = new RabbitService("Config.json", null, null, null, null);
}
public MessageBus(
IChannelPool channelPool,
ILogger <MessageBus> logger,
IMessageStorage storage = null)
{
_channelPool = channelPool;
_logger = logger;
_storage = storage;
}
public async Task <bool> TransferAllMessagesAsync(
IChannelPool originChannelPool,
IChannelPool targetChannelPool,
string originQueueName,
string targetQueueName)
{
Guard.AgainstNull(originChannelPool, nameof(originChannelPool));
Guard.AgainstNull(targetChannelPool, nameof(targetChannelPool));
Guard.AgainstNullOrEmpty(originQueueName, nameof(originQueueName));
Guard.AgainstNullOrEmpty(targetQueueName, nameof(targetQueueName));
var error = false;
var channelHost = await originChannelPool.GetChannelAsync().ConfigureAwait(false);
var properties = channelHost.Channel.CreateBasicProperties();
properties.DeliveryMode = 2;
BasicGetResult result = null;
while (true)
{
try
{
result = channelHost.Channel.BasicGet(originQueueName, true);
if (result == null)
{
break;
}
}
catch { error = true; }
finally
{
await originChannelPool
.ReturnChannelAsync(channelHost, error);
}
if (!error && result?.Body != null)
{
try
{
var targetChannelHost = await targetChannelPool.GetChannelAsync().ConfigureAwait(false);
targetChannelHost.Channel.BasicPublish(string.Empty, targetQueueName, false, properties, result.Body);
}
catch { error = true; }
finally
{
await targetChannelPool
.ReturnChannelAsync(channelHost, error);
}
}
}
return(error);
}
public Consumer(IChannelPool channelPool, ConsumerOptions consumerOptions)
{
Guard.AgainstNull(channelPool, nameof(channelPool));
Guard.AgainstNull(consumerOptions, nameof(consumerOptions));
_logger = LogHelper.GetLogger <Consumer>();
Options = channelPool.Options;
ChannelPool = channelPool;
ConsumerOptions = consumerOptions;
}
public RabbitBasicDemo(
IChannelPool channelPool,
IRabbitMqSerializer serializer,
ILogger <RabbitBasicDemo> logger)
{
_logger = logger;
this.serializer = serializer;
this.channelPool = channelPool;
ChannelAccessor = channelPool.Acquire(ChannelQueueName, ConnectionName);
}
/// <summary>
/// Use this constructor with DependencyInjection. Config's values are only used for RabbitService-esque settings and for building of Consumers.
/// </summary>
/// <param name="config"></param>
/// <param name="channelPool"></param>
/// <param name="autoPublisher"></param>
/// <param name="toploger"></param>
/// <param name="loggerFactory"></param>
public RabbitService(Config config, IChannelPool channelPool, IAutoPublisher autoPublisher, ITopologer toploger, ILoggerFactory loggerFactory = null)
{
LogHelper.LoggerFactory = loggerFactory;
Config = config;
ChannelPool = channelPool;
AutoPublisher = autoPublisher;
Topologer = toploger;
BuildConsumers();
}
public Consumer(IChannelPool channelPool, ConsumerOptions consumerSettings, byte[] hashKey = null)
{
Guard.AgainstNull(channelPool, nameof(channelPool));
Guard.AgainstNull(consumerSettings, nameof(consumerSettings));
_logger = LogHelper.GetLogger <Consumer>();
Config = channelPool.Config;
ChannelPool = channelPool;
HashKey = hashKey;
ConsumerSettings = consumerSettings;
}
public void StartInitialization()
{
ILoggerFactory connectionLoggerFactory = LoggerFactory.Create("");
IRmqLogger connectionLogger = connectionLoggerFactory.CreateLogger(nameof(ConnectionWrapper));
connection = new ConnectionWrapper(config, connectionLogger);
IModel rpcCh = connection.CreateChannel();
rpcChannelPool = channelPoolFactory.CreateChannelPool(rpcCh);
IConsumerBinder rpcConsumerBinder = new RpcConsumerBinder();
IConsumerFactory rpcConsumerFactory = new ConsumerFactory(
rpcChannelPool.GetChannelWrapper(),
rpcConsumerBinder);
ILoggerFactory loggerFactory = LoggerFactory.Create(ConsumerType.Rpc.ToString());
IRmqLogger managerLogger = loggerFactory.CreateLogger(nameof(ConsumerManager));
IConsumerManager rpcConsumerManager = new ConsumerManager(
rpcConsumerFactory,
managerLogger);
rpcConsumerManager.InitConsumer();
IMainConsumerEventHandlerFactory rpcMainEventHandlerFactory
= ConsumerEventHandlersFactory.Create(rpcConsumerManager, loggerFactory);
IConsumerMainEventHandlers rpcConsumerMainEventHandler
= rpcMainEventHandlerFactory.CreateMainHandler();
IRmqLogger connectionHandlerLogger = loggerFactory.CreateLogger(nameof(ConnectionEventHandlers));
IConnectionEventsHandlerFactory connectionEventsHandlerFactory
= ConnectionEventsHandlerFactory.Create(connectionHandlerLogger, connection);
IConnectionEventHandlers connectionEventHandler = connectionEventsHandlerFactory.CreateHandler();
IRmqLogger channelGuardLogger = loggerFactory.CreateLogger(nameof(ChannelGuardService));
this.channelGuardService
= new ChannelGuardService(
rpcChannelPool, // <--- TODO только rpc?
channelGuardLogger,
connectionEventHandler,
rpcConsumerMainEventHandler);
// Подписка на ответы запросов rpc
responseMessageHandler = responseMessageHandlerFactory.GetHandler();
rpcConsumerMainEventHandler.AddReceiveHandler(responseMessageHandler.HandleMessage);
}
public AutoPublisherTests(ITestOutputHelper output)
{
this.output = output;
options = new Options();
options.FactoryOptions.Uri = new Uri("amqp://*****:*****@localhost:5672/");
options.PublisherOptions = new PublisherOptions();
options.PublisherOptions.CreatePublishReceipts = true;
channelPool = new ChannelPool(options);
topologer = new Topologer(channelPool);
}
public AutoPublisherTests(ITestOutputHelper output)
{
this.output = output;
config = new Config();
config.FactorySettings.Uri = new Uri("amqp://*****:*****@localhost:5672/");
config.PublisherSettings = new PublisherOptions();
config.PublisherSettings.CreatePublishReceipts = true;
channelPool = new ChannelPool(config);
topologer = new Topologer(channelPool);
}
public Consumer(IChannelPool channelPool, string consumerName, byte[] hashKey = null)
{
Guard.AgainstNull(channelPool, nameof(channelPool));
Guard.AgainstNullOrEmpty(consumerName, nameof(consumerName));
_logger = LogHelper.GetLogger <Consumer>();
Config = channelPool.Config;
ChannelPool = channelPool;
HashKey = hashKey;
ConsumerSettings = Config.GetConsumerSettings(consumerName);
}
