public MyListener(IOptions <RabbitMQOptions> optionsAccessor)
: base(optionsAccessor)
{
_options = optionsAccessor.Value;
base.QueueName = _options.QueryName;
base.RouteKey = "Test.*";
}
public void TestConfiguredRabbitMQOptions()
{
ushort expectedPrefetchCount = 100;
int expectedPort = 8080;
string expectedHostName = "someHostName";
string expectedQueueName = "someQueueName";
string expectedUserName = "******";
string expectedPassword = "******";
string expectedConnectionString = "someConnectionString";
RabbitMQOptions options = new RabbitMQOptions()
{
Port = expectedPort,
HostName = expectedHostName,
QueueName = expectedQueueName,
UserName = expectedUserName,
Password = expectedPassword,
ConnectionString = expectedConnectionString,
PrefetchCount = expectedPrefetchCount,
};
Assert.Equal(expectedPrefetchCount, options.PrefetchCount);
Assert.Equal(expectedPort, options.Port);
Assert.Equal(expectedHostName, options.HostName);
Assert.Equal(expectedQueueName, options.QueueName);
Assert.Equal(expectedUserName, options.UserName);
Assert.Equal(expectedPassword, options.Password);
Assert.Equal(expectedConnectionString, options.ConnectionString);
// Test formatted
Assert.Equal(GetFormattedOption(options), options.Format());
}
public void Install(IServiceCollection services, IConfiguration configuration)
{
var rabbitConfig = new RabbitMQOptions();
var optionsFromConfig = configuration.GetSection(nameof(RabbitMQOptions));
optionsFromConfig.Bind(rabbitConfig);
var logger = services.BuildServiceProvider().GetService <ILogger <RabbitMQInstaller> >();
while (true)
{
try
{
services.AddSingleton <IEventBus>(new RabbitBus(new ConnectionFactory
{
HostName = rabbitConfig.Host,
Port = rabbitConfig.Port,
UserName = rabbitConfig.User,
Password = rabbitConfig.Password,
DispatchConsumersAsync = true,
}, services.BuildServiceProvider()));
break;
}
catch
{
logger.LogInformation("Failed connect to RabbitMQ. Sleep 10s...");
Thread.Sleep(10000);
}
}
}
public QueueService(RabbitMQOptions options)
{
_options = options;
var protocol = "amqp";
var sslOption = new SslOption();
if (_options.EnableSsl)
{
sslOption.Enabled = true;
sslOption.ServerName = _options.Host;
sslOption.AcceptablePolicyErrors |= System.Net.Security.SslPolicyErrors.RemoteCertificateNameMismatch;
protocol = "amqps";
}
_factory = new ConnectionFactory()
{
Ssl = sslOption,
TopologyRecoveryEnabled = false,
AutomaticRecoveryEnabled = true,
Uri = new Uri($"{protocol}://{_options.Username}:{_options.Password}@{_options.Host}:{_options.Port}"),
NetworkRecoveryInterval = TimeSpan.FromSeconds(10),
};
_factory.Ssl.CertificateValidationCallback
+= (object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) => true;
_connection = _factory.CreateConnection();
_requestChannel = _connection.CreateModel();
}
public MQConsumerClient(string queueName, IConnectionChannelPool connectionChannelPool, IOptions <RabbitMQOptions> options)
{
_queueName = queueName;
_connectionChannelPool = connectionChannelPool;
_rabbitMQOptions = options.Value;
_exchangeName = connectionChannelPool.Exchange;
}
public static IServiceCollection AddBus(this IServiceCollection services, string section, IConfiguration configuration)
{
var configurationOptions = configuration.GetSection(section);
var options = new RabbitMQOptions();
configurationOptions.Bind(options);
_hostName = options.HostName;
services.AddSingleton(provider => global::MassTransit.Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(options.Server, options.VirtualHost, h =>
{
h.Username(options.UserName);
h.Password(options.Password);
});
cfg.SetLoggerFactory(provider.GetService <ILoggerFactory>());
foreach (var handlerAction in _addEndpointAndConsumerActionList)
{
handlerAction(provider, cfg, host);
}
}));
services.AddSingleton <IPublishEndpoint>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <ISendEndpointProvider>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <IBus>(provider => provider.GetRequiredService <IBusControl>());
services.AddScoped <IEventBus, TransitBus>();
services.AddSingleton <IHostedService, BusService>();
return(services);
}
private static Func <IConnection> CreateConnection(RabbitMQOptions options)
{
//var serviceName = Assembly.GetEntryAssembly()?.GetName().Name.ToLower();
//heng
var assembly = BuildManager.GetGlobalAsaxType().BaseType.Assembly;
var serviceName = assembly?.GetName().Name.ToLower();
var factory = new ConnectionFactory
{
UserName = options.UserName,
Port = options.Port,
Password = options.Password,
VirtualHost = options.VirtualHost
};
if (options.HostName.Contains(","))
{
options.ConnectionFactoryOptions?.Invoke(factory);
return(() => factory.CreateConnection(
options.HostName.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries), serviceName));
}
factory.HostName = options.HostName;
options.ConnectionFactoryOptions?.Invoke(factory);
return(() => factory.CreateConnection(serviceName));
}
public void Creates_Context_Correctly()
{
var options = new RabbitMQOptions {
HostName = Constants.LocalHost, RoutingKey = "hello"
};
var loggerFactory = new LoggerFactory();
var mockServiceFactory = new Mock <IRabbitMQServiceFactory>();
var mockNameResolver = new Mock <INameResolver>();
var config = new RabbitMQExtensionConfigProvider(new OptionsWrapper <RabbitMQOptions>(options), mockNameResolver.Object, mockServiceFactory.Object, (ILoggerFactory)loggerFactory, _emptyConfig);
var attribute = new RabbitMQAttribute {
HostName = "131.107.174.10", RoutingKey = "route"
};
var actualContext = config.CreateContext(attribute);
RabbitMQAttribute attr = new RabbitMQAttribute
{
HostName = "131.107.174.10",
RoutingKey = "route",
};
RabbitMQContext expectedContext = new RabbitMQContext
{
ResolvedAttribute = attr,
};
Assert.Equal(actualContext.ResolvedAttribute.HostName, expectedContext.ResolvedAttribute.HostName);
Assert.Equal(actualContext.ResolvedAttribute.RoutingKey, expectedContext.ResolvedAttribute.RoutingKey);
}
public static EventBusOptionsBuilder UseRabbitMQ(this EventBusOptionsBuilder optionsBuilder, ILinFxBuilder fx, Action <RabbitMQOptions> optionsAction)
{
Check.NotNull(optionsAction, nameof(optionsAction));
var options = new RabbitMQOptions();
optionsAction?.Invoke(options);
fx.AddRabbitMQ(x =>
{
x.Host = options.Host;
x.UserName = options.UserName;
x.Password = options.Password;
});
fx.Services.AddSingleton <IEventBus, EventBusRabbitMQ>(sp =>
{
var logger = sp.GetRequiredService <ILogger <EventBusRabbitMQ> >();
var rabbitMQPersistentConnection = sp.GetRequiredService <IRabbitMQPersistentConnection>();
var iServiceScopeFactory = sp.GetRequiredService <IServiceScopeFactory>();
var eventBusSubcriptionsManager = sp.GetRequiredService <IEventBusSubscriptionsManager>();
return(new EventBusRabbitMQ(logger, rabbitMQPersistentConnection, eventBusSubcriptionsManager, iServiceScopeFactory, optionsBuilder.Options));
});
return(optionsBuilder);
}
public RabbitMQAdapterSender(ILoggerFactory loggerFactory, SerializationManager serializationManager,
IConnection connection, string queueName, RabbitMQOptions queueOptions)
{
_serializationManager = serializationManager;
_connection = connection;
_queueName = queueName;
_queueOptions = queueOptions;
}
public RabbitMQBus(RabbitMQOptions rabbitMQOptions, RabbitMQProtocol protocol, ILogger <RabbitMQBus> logger, string queueName)
{
this._Logger = logger;
this._RabbitMQOptions = rabbitMQOptions;
this._Protocol = protocol;
this._QueueName = queueName;
this._ackHandler = new AckHandler();
}
public RabbitMQConsumerClient(string queueName, string topicExchangeName, RabbitMQOptions options)
{
_queueName = queueName;
_topicExchangeName = topicExchangeName;
_rabbitMQOptions = options;
InitClient();
}
public RabbitMQConnector(RabbitMQOptions options, QueueId queueId, ILogger logger)
{
_options = options;
Logger = logger;
QueueName = options.UseQueuePartitioning
? $"{options.QueueNamePrefix}-{queueId.GetNumericId()}"
: options.QueueNamePrefix;
}
public RabbitMQAdapterReceiver(SerializationManager serializationManager,
ILoggerFactory loggerFactory, IConnection connection, RabbitMQOptions queueOptions, string queueName)
{
_logger = loggerFactory.CreateLogger <RabbitMQAdapterReceiver>();
_serializationManager = serializationManager;
_connection = connection;
_queueOptions = queueOptions;
_queueName = queueName;
}
public static MagnetServerBuilder AddRabbitMQ(
this MagnetServerBuilder builder,
IConfiguration configuration)
{
IConfigurationSection section = configuration.GetSection("Magnet:RabbitMQ");
RabbitMQOptions options = section.Get <RabbitMQOptions>();
builder.AddRabbitMQ(options);
return(builder);
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="connection">连接对象</param>
/// <param name="options">配置对象</param>
/// <param name="consumerOptions">消费者配置对象</param>
/// <param name="producerOptions">生产者配置对象</param>
/// <param name="loggerFactory">日志工厂</param>
public ConnectionObject(IConnection connection, RabbitMQOptions options, ConsumerOptions consumerOptions, ProducerOptions producerOptions, ILoggerFactory loggerFactory)
{
channels = new List <ChannelObject>();
this.connection = connection;
RabbitMQOptions = options;
ConsumerOptions = consumerOptions;
ProducerOptions = producerOptions;
this.loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
logger = loggerFactory.CreateLogger <ConnectionObject>();
}
public EventBusRabbitMQ(IOptionsMonitor <RabbitMQOptions> options,
PersistentConnection connection,
IEventExecutor eventExecutor, ILogger <EventBusRabbitMQ> logger
)
{
_options = options.CurrentValue;
_logger = logger;
_eventExecutor = eventExecutor;
_connection = connection;
_consumerChannel = CreateConsumerChannel();
}
public static IServiceCollection AddRabbitMQ(this IServiceCollection services, Action <RabbitMQOptions> optionsAction)
{
RabbitMQOptions options = new RabbitMQOptions();
services.Configure(optionsAction);
services.TryAddSingleton <ITransportSender, RabbitMQTransportSender>();
services.TryAddSingleton <IMessageSubscribeFactory, RabbitMQMessageSubscribeFactory>();
services.TryAddSingleton <IRabbitMQBrokerConnector, RabbitMQBrokerConnector>();
return(services);
}
public RabbitMQConsumerClient(string queueName,
IConnectionChannelPool connectionChannelPool,
RabbitMQOptions options)
{
_queueName = queueName;
_connectionChannelPool = connectionChannelPool;
_rabbitMQOptions = options;
_exchangeName = connectionChannelPool.Exchange;
InitClient();
}
public static IServiceCollection AddRabbitMQEventBus(this IServiceCollection services, Action <RabbitMQOptions> configure)
{
var rabbitMQOptions = new RabbitMQOptions();
configure?.Invoke(rabbitMQOptions);
services.AddSingleton(rabbitMQOptions);
services.AddSingleton <IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();
services.AddSingleton <IRabbitMQConnectionManager, RabbitMQConnectionManager>();
services.AddSingleton <IEventBus, RabbitMQEventBus>();
return(services);
}
public RabbitMQBrokerConnector(
IOptions <RabbitMQOptions> options,
ILogger <RabbitMQBrokerConnector> logger)
{
_options = options.Value;
_logger = logger;
_maxSize = _options.KeepConnectionNumber;
_pool = new ConcurrentQueue <IModel>();
_connectionActivator = CreateConnection(_options);
}
private string GetFormattedOption(RabbitMQOptions option)
{
JObject options = new JObject
{
{ nameof(option.HostName), option.HostName },
{ nameof(option.QueueName), option.QueueName },
{ nameof(option.Port), option.Port },
{ nameof(option.PrefetchCount), option.PrefetchCount },
};
return(options.ToString(Formatting.Indented));
}
public static void AddRabbitMQ(this IServiceCollection services, IConfiguration configuration, string sectionName = "rabbitmq")
{
var options = new RabbitMQOptions();
var section = configuration.GetSection(sectionName);
section.Bind(options);
var client = RawRabbitFactory.CreateSingleton(new RawRabbitOptions
{
ClientConfiguration = options
});
services.AddSingleton <IBusClient>(client);
}
public void AddServices(IServiceCollection services)
{
services.AddSingleton <CapMessageQueueMakerService>();
var options = new RabbitMQOptions();
_configure?.Invoke(options);
services.AddSingleton(options);
services.AddSingleton <IConsumerClientFactory, RabbitMQConsumerClientFactory>();
services.AddSingleton <IConnectionChannelPool, ConnectionChannelPool>();
services.AddSingleton <IPublishExecutor, RabbitMQPublishMessageSender>();
services.AddSingleton <IPublishMessageSender, RabbitMQPublishMessageSender>();
}
public static IMQFactory AddRabbitMQ(this IMQFactory factory, Action <RabbitMQOptions> action)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
RabbitMQOptions options = new RabbitMQOptions();
action?.Invoke(options);
factory.AddProvider(new RabbitMQProvider(options));
return(factory);
}
/// <summary>
/// 添加RabbitMQ消息总线
/// </summary>
/// <param name="services"> IServiceCollection </param>
/// <param name="configuration"> 配置文件对象(RabbitMQOptions) </param>
/// <returns> </returns>
public static IServiceCollection AddRabbitMQMessagBus(this IServiceCollection services, IConfiguration configuration)
=> AddRabbitMQMessagBus(services, config =>
{
var rabbitMQOptions = new RabbitMQOptions();
ConfigurationHelper.GetConfiguration(configuration, nameof(RabbitMQOptions)).Bind(rabbitMQOptions);
config.UserName = rabbitMQOptions.UserName;
config.Password = rabbitMQOptions.Password;
config.VirtualHost = rabbitMQOptions.VirtualHost;
config.ChannelPoolSize = rabbitMQOptions.ChannelPoolSize;
config.ConnectionPoolSize = rabbitMQOptions.ConnectionPoolSize;
config.HostNames = rabbitMQOptions.HostNames;
config.ExchangeName = rabbitMQOptions.ExchangeName;
});
public void TestDefaultOptions()
{
RabbitMQOptions options = new RabbitMQOptions();
Assert.Equal <ushort>(30, options.PrefetchCount);
Assert.Equal(0, options.Port);
Assert.Null(options.HostName);
Assert.Null(options.QueueName);
Assert.Null(options.UserName);
Assert.Null(options.Password);
Assert.Null(options.ConnectionString);
// Test formatted
Assert.Equal(GetFormattedOption(options), options.Format());
}
public RabbitMQAdapter(
SerializationManager serializationManager,
IRabbitMQStreamQueueMapper streamQueueMapper,
ILoggerFactory loggerFactory,
RabbitMQOptions queueOptions,
string serviceId,
string providerName)
{
_serializationManager = serializationManager;
QueueOptions = queueOptions;
ServiceId = serviceId;
Name = providerName;
_streamQueueMapper = streamQueueMapper;
_loggerFactory = loggerFactory;
}
public IConnection CreateRabbitConnection(RabbitMQOptions options)
{
var factory = new ConnectionFactory
{
RequestedConnectionTimeout = new TimeSpan(0, 0, 2),
AutomaticRecoveryEnabled = true,
HostName = options.HostName,
UserName = options.UserName,
Port = options.Port,
Password = options.Password,
VirtualHost = options.VirtualHost
};
return(factory.CreateConnection());
}
public RabbitMQAdapterFactory(
ILoggerFactory loggerFactory,
string name,
RabbitMQOptions options,
SimpleQueueCacheOptions cacheOptions,
IOptions <ClusterOptions> clusterOptions,
SerializationManager serializationManager)
{
_providerName = name;
_options = options ?? throw new ArgumentNullException(nameof(options));
_clusterOptions = clusterOptions.Value;
SerializationManager = serializationManager ?? throw new ArgumentNullException(nameof(serializationManager));
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_streamQueueMapper = new RabbitMQStreamQueueMapper(options, $"{options.QueuePrefix}-{name}");
_adapterCache = new SimpleQueueAdapterCache(cacheOptions, _providerName, _loggerFactory);
}
