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); }