public void DefaultMessageBusOptionValues() { var options = new MessageBusOptions(); Assert.Equal(1000, options.MessageBufferSize); Assert.Equal(1000, options.MaxTopicsWithNoSubscriptions); }
public static MessageBusOptions ReadFromConfiguration(IConfiguration config, AppOptions appOptions) { var options = new MessageBusOptions(); options.Scope = appOptions.AppScope; options.ScopePrefix = !String.IsNullOrEmpty(options.Scope) ? options.Scope + "-" : String.Empty; options.Topic = config.GetValue <string>(nameof(options.Topic), $"{options.ScopePrefix}messages"); string cs = config.GetConnectionString("MessageBus"); options.Data = cs.ParseConnectionString(); options.Provider = options.Data.GetString(nameof(options.Provider)); var providerConnectionString = !String.IsNullOrEmpty(options.Provider) ? config.GetConnectionString(options.Provider) : null; if (!String.IsNullOrEmpty(providerConnectionString)) { options.Data.AddRange(providerConnectionString.ParseConnectionString()); } options.ConnectionString = options.Data.BuildConnectionString(new HashSet <string> { nameof(options.Provider) }); return(options); }
public async Task ConfigureAsync(IEnumerable <MessageHandlerMapping> messageHandlerMappings, MessageBusOptions options) { _messageVersionPropertyName = options?.MessageVersionPropertyName; await CreateOrUpdateSubscriptionAsync(); await UpdateRulesAsync(messageHandlerMappings); }
protected AbstractProvider(IServiceProvider serviceProvider, MessageBusOptions options) { ServiceProvider = serviceProvider; Options = options; LoggerFactory = serviceProvider.GetService <ILoggerFactory>(); Logger = LoggerFactory.CreateLogger(GetType()); }
public static IServiceCollection AddMessageBus(this IServiceCollection services, Action <MessageBusOptions> optionsAction) { var options = new MessageBusOptions(); optionsAction?.Invoke(options); services.TryAddSingleton <IMessageBusOptions>(options); return(services); }
public static IServiceCollection AddRabbitMQ(this IServiceCollection services, string connectionString, ServiceLifetime serviceLifetime, Action <MessageBusOptions> options) { var op = new MessageBusOptions(); options?.Invoke(op); services.AddSingleton(op); services.Add(new ServiceDescriptor(typeof(IAdvancedBus), s => RabbitHutch.CreateBus(connectionString).Advanced, serviceLifetime)); return(services); }
public MqttMessageReceivedEventHandler( IServiceProvider serviceProvider, MessageBusOptions messageBusOptions, IMqttClient mqttClient ) { _serviceProvider = serviceProvider; _messageBusOptions = messageBusOptions; _mqttClient = mqttClient; }
public static IServiceCollection AddCqrs(this IServiceCollection services, Action <PipelineOptionsBuilder, PipelineOptionsBuilder> configure) { var options = new MessageBusOptions(); configure?.Invoke(options.Commands.Builder, options.Queries.Builder); services.TryAddTransient(s => new MessageBus(s, options)); return(services); }
public static AppOptions ReadFromConfiguration(IConfiguration config) { var options = new AppOptions(); options.BaseURL = config.GetValue <string>(nameof(options.BaseURL))?.TrimEnd('/'); options.InternalProjectId = config.GetValue(nameof(options.InternalProjectId), "54b56e480ef9605a88a13153"); options.ExceptionlessApiKey = config.GetValue <string>(nameof(options.ExceptionlessApiKey)); options.ExceptionlessServerUrl = config.GetValue <string>(nameof(options.ExceptionlessServerUrl)); options.AppMode = config.GetValue(nameof(options.AppMode), AppMode.Production); options.AppScope = config.GetValue(nameof(options.AppScope), options.AppMode.ToScope()); options.RunJobsInProcess = config.GetValue(nameof(options.RunJobsInProcess), options.AppMode == AppMode.Development); options.JobsIterationLimit = config.GetValue(nameof(options.JobsIterationLimit), -1); options.BotThrottleLimit = config.GetValue(nameof(options.BotThrottleLimit), 25).NormalizeValue(); options.ApiThrottleLimit = config.GetValue(nameof(options.ApiThrottleLimit), options.AppMode == AppMode.Development ? Int32.MaxValue : 3500).NormalizeValue(); options.EnableArchive = config.GetValue(nameof(options.EnableArchive), true); options.EnableSampleData = config.GetValue(nameof(options.EnableSampleData), options.AppMode != AppMode.Development); options.EventSubmissionDisabled = config.GetValue(nameof(options.EventSubmissionDisabled), false); options.DisabledPipelineActions = config.GetValueList(nameof(options.DisabledPipelineActions)); options.DisabledPlugins = config.GetValueList(nameof(options.DisabledPlugins)); options.MaximumEventPostSize = config.GetValue(nameof(options.MaximumEventPostSize), 200000).NormalizeValue(); options.MaximumRetentionDays = config.GetValue(nameof(options.MaximumRetentionDays), 180).NormalizeValue(); options.GoogleGeocodingApiKey = config.GetValue <string>(nameof(options.GoogleGeocodingApiKey)); options.MaxMindGeoIpKey = config.GetValue <string>(nameof(options.MaxMindGeoIpKey)); options.BulkBatchSize = config.GetValue(nameof(options.BulkBatchSize), 1000); options.EnableRepositoryNotifications = config.GetValue(nameof(options.EnableRepositoryNotifications), true); options.EnableWebSockets = config.GetValue(nameof(options.EnableWebSockets), true); try { var versionInfo = FileVersionInfo.GetVersionInfo(typeof(AppOptions).Assembly.Location); options.Version = versionInfo.FileVersion; options.InformationalVersion = versionInfo.ProductVersion; } catch { } options.CacheOptions = CacheOptions.ReadFromConfiguration(config, options); options.MessageBusOptions = MessageBusOptions.ReadFromConfiguration(config, options); options.MetricOptions = MetricOptions.ReadFromConfiguration(config); options.QueueOptions = QueueOptions.ReadFromConfiguration(config, options); options.StorageOptions = StorageOptions.ReadFromConfiguration(config, options); options.EmailOptions = EmailOptions.ReadFromConfiguration(config, options); options.ElasticsearchOptions = ElasticsearchOptions.ReadFromConfiguration(config, options); options.IntercomOptions = IntercomOptions.ReadFromConfiguration(config); options.SlackOptions = SlackOptions.ReadFromConfiguration(config); options.StripeOptions = StripeOptions.ReadFromConfiguration(config); options.AuthOptions = AuthOptions.ReadFromConfiguration(config); return(options); }
private static void RegisterMessageBus(IServiceCollection container, MessageBusOptions options) { if (String.Equals(options.Provider, "redis")) { container.AddSingleton <ConnectionMultiplexer>(s => ConnectionMultiplexer.Connect(options.Data.GetString("server"))); container.ReplaceSingleton <IMessageBus>(s => new RedisMessageBus(new RedisMessageBusOptions { Subscriber = s.GetRequiredService <ConnectionMultiplexer>().GetSubscriber(), Topic = $"{options.ScopePrefix}messages", Serializer = s.GetRequiredService <ISerializer>(), LoggerFactory = s.GetRequiredService <ILoggerFactory>() })); } }
public void SetsMessageTypePropertyName(string messageTypePropertyName) { var sut = new MessageBusOptions(); if (!string.IsNullOrWhiteSpace(messageTypePropertyName)) { sut.MessageTypePropertyName = messageTypePropertyName; Assert.Equal(messageTypePropertyName, sut.MessageTypePropertyName); } else { Assert.Equal("MessageType", sut.MessageTypePropertyName); } }
public static IServiceCollection AddRebus <THandler>(this IServiceCollection services, IConfiguration configuration, Action <StandardConfigurer <IRouter> > action = null) { var rebusConfig = new MessageBusOptions(); configuration.Bind(MessageBusOptions.Section, rebusConfig); var configureRebus = ConfigureRebus(services, rebusConfig, action); services.Configure <MessageBusOptions>(configuration.GetSection(MessageBusOptions.Section)); services.AddTransient(resolver => resolver.GetService <IOptionsMonitor <MessageBusOptions> >().CurrentValue); services.AutoRegisterHandlersFromAssemblyOf <THandler>(); services.AddRebus(configureRebus); services.AddScoped <IMessageBus, RebusMessageBus>(); return(services); }
/// <summary> /// /// </summary> /// <param name="options"></param> public RabbitMessageBus(MessageBusOptions options) { Throws.ArgumentNullException(options, nameof(options)); Throws.ArgumentNullException(options.HostName, nameof(options.HostName)); Throws.ArgumentNullException(options.UserName, nameof(options.UserName)); Throws.ArgumentNullException(options.Password, nameof(options.Password)); this._connectionFactory = new ConnectionFactory { HostName = options.HostName, UserName = options.UserName, Password = options.Password, AutomaticRecoveryEnabled = options.AutomaticRecoveryEnabled, NetworkRecoveryInterval = options.NetworkRecoveryInterval }; }
public static IMessageBus GetBusInstance(IServiceProvider serviceProvider, MessageBusOptions options) { AbstractProvider provider; string assemblyName = $"Colder.MessageBus.{options.Transport}"; try { Assembly assembly = Assembly.Load(assemblyName); var type = assembly.GetType($"{assemblyName}.{options.Transport}Provider"); provider = Activator.CreateInstance(type, new object[] { serviceProvider, options }) as AbstractProvider; } catch { throw new Exception($"请安装nuget包:{assemblyName}"); } return(provider.GetBusInstance()); }
private static void RegisterMessageBus(IServiceCollection container, MessageBusOptions options) { if (String.Equals(options.Provider, "redis")) { container.ReplaceSingleton(s => GetRedisConnection(options.Data)); container.ReplaceSingleton <IMessageBus>(s => new RedisMessageBus(new RedisMessageBusOptions { Subscriber = s.GetRequiredService <ConnectionMultiplexer>().GetSubscriber(), Topic = options.Topic, Serializer = s.GetRequiredService <ISerializer>(), LoggerFactory = s.GetRequiredService <ILoggerFactory>() })); } else if (String.Equals(options.Provider, "rabbitmq")) { container.ReplaceSingleton <IMessageBus>(s => new RabbitMQMessageBus(new RabbitMQMessageBusOptions { ConnectionString = options.ConnectionString, Topic = options.Topic, Serializer = s.GetRequiredService <ISerializer>(), LoggerFactory = s.GetRequiredService <ILoggerFactory>() })); } }
public static IServiceCollection AddMessageBus(this IServiceCollection services, string hostName, int port, string virtualhostName, string exchangeName, string queueName, string userName, string password, string hostServiceName = default, bool?queuePerConsumer = default) { var options = new MessageBusOptions() { HostName = hostName, Port = port, VirtualHost = virtualhostName, ExchangeName = exchangeName, QueueName = queueName, UserName = userName, Password = password, HostServiceName = hostServiceName, UseServiceDiscovery = !string.IsNullOrWhiteSpace(hostServiceName), QueuePerConsumer = queuePerConsumer }; services.TryAddSingleton <IMessageBusOptions>(options); return(services); }
/// <summary> /// 注入自定义消息总线 /// 注:可以通过此方法注入多个总线 /// </summary> /// <typeparam name="TMessageBus">自定义总线类型</typeparam> /// <param name="services">服务容器</param> /// <param name="options">配置</param> /// <returns></returns> public static IServiceCollection AddMessageBus <TMessageBus>(this IServiceCollection services, MessageBusOptions options) where TMessageBus : class, IMessageBus { if (!typeof(TMessageBus).IsPublic) { throw new Exception($"{typeof(TMessageBus).FullName}必须公开"); } services.AddHostedService <MessageBusBootstraper>(); MessageBusBootstraper.Bootstrap += serviceProvider => serviceProvider.GetService <TMessageBus>(); return(services.AddSingleton(serviceProvider => { var busInstance = MessageBusFactory.GetBusInstance(serviceProvider, options); if (typeof(TMessageBus) == typeof(IMessageBus)) { return (TMessageBus)busInstance; } else { return Generator.CreateInterfaceProxyWithoutTarget <TMessageBus>(new ActLikeInterceptor(busInstance)); } })); }
public MassTransitMessageBus(IBusControl busControl, MessageBusOptions options) { _busControl = busControl; _options = options; }
/// <summary> /// 注入消息总线 /// </summary> /// <param name="services">服务容器</param> /// <param name="options">配置</param> /// <returns></returns> public static IServiceCollection AddMessageBus(this IServiceCollection services, MessageBusOptions options) { return(AddMessageBus <IMessageBus>(services, options)); }
private static IHealthChecksBuilder RegisterHealthChecks(IServiceCollection services, CacheOptions cacheOptions, MessageBusOptions messageBusOptions, MetricOptions metricOptions, StorageOptions storageOptions, QueueOptions queueOptions) { services.AddStartupActionToWaitForHealthChecks("Critical"); return(services.AddHealthChecks() .AddCheckForStartupActions("Critical") .AddAutoNamedCheck <ElasticsearchHealthCheck>("Critical") .AddAutoNamedCheck <CacheHealthCheck>("Critical") .AddAutoNamedCheck <StorageHealthCheck>("EventPosts", "AllJobs") .AddAutoNamedCheck <QueueHealthCheck <EventPost> >("EventPosts", "AllJobs") .AddAutoNamedCheck <QueueHealthCheck <EventUserDescription> >("EventUserDescriptions", "AllJobs") .AddAutoNamedCheck <QueueHealthCheck <EventNotificationWorkItem> >("EventNotifications", "AllJobs") .AddAutoNamedCheck <QueueHealthCheck <WebHookNotification> >("WebHooks", "AllJobs") .AddAutoNamedCheck <QueueHealthCheck <MailMessage> >("AllJobs") .AddAutoNamedCheck <QueueHealthCheck <WorkItemData> >("WorkItem", "AllJobs") .AddAutoNamedCheck <CloseInactiveSessionsJob>("AllJobs") .AddAutoNamedCheck <DailySummaryJob>("AllJobs") .AddAutoNamedCheck <DownloadGeoIPDatabaseJob>("AllJobs") .AddAutoNamedCheck <MaintainIndexesJob>("AllJobs") .AddAutoNamedCheck <RetentionLimitsJob>("AllJobs") .AddAutoNamedCheck <StackEventCountJob>("AllJobs")); }
public RabbitMessageBusPublisher(IAdvancedBus bus, ExchangeConfiguration exchangeConfiguration, QueueConfiguration queueConfiguration, MessageBusOptions options) : base(bus, exchangeConfiguration, queueConfiguration) { _options = options; }
public RabbitMQProvider(IServiceProvider serviceProvider, MessageBusOptions options) : base(serviceProvider, options) { }
public MQTTProvider(IServiceProvider serviceProvider, MessageBusOptions options) : base(serviceProvider, options) { }
private static Func <RebusConfigurer, IServiceProvider, RebusConfigurer> ConfigureRebus(IServiceCollection services, MessageBusOptions rebusConfig, Action <StandardConfigurer <IRouter> > action) { void ConfigureRabbit(StandardConfigurer <ITransport> t) { t.UseRabbitMq(rebusConfig.ConnectionString, rebusConfig.Queue) .ExchangeNames(DirectExchange, TopicExchange) .Prefetch(rebusConfig.Prefetch); } void ConfigureAzure(StandardConfigurer <ITransport> t) { t.UseAzureServiceBus(rebusConfig.ConnectionString, rebusConfig.Queue) .AutomaticallyRenewPeekLock() .EnablePrefetching(rebusConfig.Prefetch); } void ConfigureMemory(StandardConfigurer <ITransport> t, IServiceProvider serviceProvider) { t.UseInMemoryTransport(serviceProvider.GetService <InMemNetwork>(), rebusConfig.Queue); } void ConfigureTransport(StandardConfigurer <ITransport> t, IServiceProvider serviceProvider) { switch (rebusConfig.Transport) { case MessageBusOptions.TransportOptions.Azure: ConfigureAzure(t); break; case MessageBusOptions.TransportOptions.Rabbit: ConfigureRabbit(t); break; case MessageBusOptions.TransportOptions.Memory: ConfigureMemory(t, serviceProvider); break; default: throw new ArgumentOutOfRangeException(); } } void ConfigureLogging(RebusLoggingConfigurer l, IServiceProvider serviceProvider) { l.MicrosoftExtensionsLogging(serviceProvider.GetService <ILoggerFactory>()); } void ConfigureSagas(StandardConfigurer <ISagaStorage> s, IServiceProvider serviceProvider) { if (rebusConfig.Transport == MessageBusOptions.TransportOptions.Memory) { s.StoreInMemory(); } else { s.StoreInMongoDb(serviceProvider.GetService <IMongoDatabase>()); } } void ConfigureSerialization(StandardConfigurer <ISerializer> s, IServiceProvider serviceProvider) { s.UseNewtonsoftJson(JsonInteroperabilityMode.FullTypeInformation); } void ConfigureOptions(OptionsConfigurer o, IServiceProvider serviceProvider) { o.EnableIdempotentSagas(); o.SetMaxParallelism(rebusConfig.MaxParallelism); o.SetNumberOfWorkers(rebusConfig.NumberOfWorkers); o.SimpleRetryStrategy(maxDeliveryAttempts: rebusConfig.Retry, errorQueueAddress: rebusConfig.ErrorQueue); } void ConfigureTimeouts(StandardConfigurer <ITimeoutManager> t, IServiceProvider serviceProvider) { if (rebusConfig.Transport == MessageBusOptions.TransportOptions.Memory) { t.StoreInMemory(); } else { t.StoreInMongoDb(serviceProvider.GetService <IMongoDatabase>(), "TimeOutRebus"); } } void Subscriptions(StandardConfigurer <ISubscriptionStorage> t) { if (rebusConfig.Transport == MessageBusOptions.TransportOptions.Memory) { t.StoreInMemory(); } } return((configure, provider) => configure .Logging(it => ConfigureLogging(it, provider)) .Transport(it => ConfigureTransport(it, provider)) .Sagas(it => ConfigureSagas(it, provider)) .Serialization(it => ConfigureSerialization(it, provider)) .Subscriptions(Subscriptions) .Options(it => ConfigureOptions(it, provider)) .Timeouts(it => ConfigureTimeouts(it, provider)) .Routing(r => action?.Invoke(r))); }
public RabbitMessageBusConsumer(IAdvancedBus bus, ExchangeConfiguration exchangeConfiguration, QueueConfiguration queueConfiguration, ILogger <RabbitMessageBusConsumer <T> > logger, MessageBusOptions options) : base(bus, exchangeConfiguration, queueConfiguration, options) { _logger = logger; ConfigureBusEvents(); }
public InMemoryProvider(IServiceProvider serviceProvider, MessageBusOptions options) : base(serviceProvider, options) { }
protected MassTransitProvider(IServiceProvider serviceProvider, MessageBusOptions options) : base(serviceProvider, options) { }
public SignalROptions() { Hubs = new HubOptions(); MessageBus = new MessageBusOptions(); Transports = new TransportOptions(); }
public MqttMessageBus(MessageBusOptions options, IMqttClient mqttClient) { _options = options; _mqttClient = mqttClient; }
internal MessageBus(IServiceProvider services, MessageBusOptions options) { _services = services; _options = options; }