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