public static void AddCustomMassTransit(this IServiceCollection services, IConfiguration configuration)
{
var options = new MassTransitOptions();
configuration.GetSection("RabbitMq").Bind(options);
services.AddMassTransit(appProvider =>
{
return(Bus.Factory.CreateUsingRabbitMq(
configurator =>
{
var host = configurator.Host(new Uri($"{options.Host}:{options.Port}"), h =>
{
h.Username(options.Username);
h.Password(options.Password);
});
configurator.ReceiveEndpoint(host, "user_updated_events", ep =>
{
ep.Handler <UserUpdatedEvent>(async context =>
{
await services.BuildServiceProvider()
.GetRequiredService <IEventHandler <UserUpdatedEvent> >().Handle(context.Message);
});
});
}));
});
}
public static IServiceCollection AddNybusLegacyWithMassTransit(this IServiceCollection services, NybusLegacyConfiguration configuration)
{
services.AddNybusLegacy(configuration.NybusConfigurator, configuration.SubscriptionsConfigurator);
services.AddSingleton(sp =>
{
var options = new MassTransitOptions();
configuration.MassTransitConfigurator?.Invoke(options);
return(options);
});
services.AddSingleton(sp =>
{
var cfg = sp.GetRequiredService <IConfiguration>();
var connectionString = cfg.GetConnectionString(configuration.ConnectionStringName);
return(MassTransitConnectionDescriptor.Parse(connectionString));
});
services.AddSingleton <IBusEngine>(sp =>
{
var descriptor = sp.GetRequiredService <MassTransitConnectionDescriptor>();
var options = sp.GetRequiredService <MassTransitOptions>();
return(new MassTransitBusEngine(descriptor, options));
});
return(services);
}
public IBusControl CreateServiceBus(MassTransitOptions options, IReadOnlyList <Action <IReceiveEndpointConfigurator> > commandSubscriptions, IReadOnlyList <Action <IReceiveEndpointConfigurator> > eventSubscriptions)
{
return(Bus.Factory.CreateUsingInMemory(cfg =>
{
cfg.UseJsonSerializer();
cfg.UseConcurrencyLimit(options.ConcurrencyLimit);
if (commandSubscriptions.Any())
{
cfg.ReceiveEndpoint(options.CommandQueueNameStrategy.GetQueueName(), endpoint =>
{
endpoint.UseRetry(options.CommandErrorPolicy);
foreach (var subscription in commandSubscriptions)
{
subscription(endpoint);
}
});
}
if (eventSubscriptions.Any())
{
cfg.ReceiveEndpoint(options.EventQueueNameStrategy.GetQueueName(), endpoint =>
{
endpoint.UseRetry(options.EventErrorPolicy);
foreach (var subscription in eventSubscriptions)
{
subscription(endpoint);
}
});
}
}));
}
public static void AddMassTransit(this IServiceCollection serviceCollection, Action <MassTransitOptions> opt = null)
{
var options = new MassTransitOptions(serviceCollection);
serviceCollection.AddSingleton(options);
if (opt == null)
{
opt(options);
}
}
public void Initialize()
{
fixture = new Fixture();
commandQueueName = fixture.Create <string>();
eventQueueName = fixture.Create <string>();
mockLoggerFactory = new Mock <ILoggerFactory>();
mockLogger = new Mock <ILogger>();
mockLoggerFactory.Setup(p => p.CreateLogger(It.IsAny <string>())).Returns(() => mockLogger.Object);
mockContextManager = new Mock <IContextManager>();
mockCommandErrorStrategy = new Mock <IErrorStrategy>();
mockCommandQueueStrategy = new Mock <IQueueStrategy>();
mockCommandServiceBus = new Mock <IServiceBus>();
mockEventErrorStrategy = new Mock <IErrorStrategy>();
mockEventQueueStrategy = new Mock <IQueueStrategy>();
mockEventServiceBus = new Mock <IServiceBus>();
mockServiceBusFactory = new Mock <IServiceBusFactory>();
mockServiceBusFactory.Setup(p => p.CreateServiceBus(It.IsAny <MassTransitConnectionDescriptor>(), mockCommandQueueStrategy.Object, It.IsAny <IReadOnlyList <Action <SubscriptionBusServiceConfigurator> > >())).Returns(mockCommandServiceBus.Object);
mockServiceBusFactory.Setup(p => p.CreateServiceBus(It.IsAny <MassTransitConnectionDescriptor>(), mockEventQueueStrategy.Object, It.IsAny <IReadOnlyList <Action <SubscriptionBusServiceConfigurator> > >())).Returns(mockEventServiceBus.Object);
mockCommandQueueStrategy.Setup(p => p.GetQueueName()).Returns(commandQueueName);
mockEventQueueStrategy.Setup(p => p.GetQueueName()).Returns(eventQueueName);
options = new MassTransitOptions
{
LoggerFactory = mockLoggerFactory.Object,
CommandErrorStrategy = mockCommandErrorStrategy.Object,
CommandQueueStrategy = mockCommandQueueStrategy.Object,
EventErrorStrategy = mockEventErrorStrategy.Object,
EventQueueStrategy = mockEventQueueStrategy.Object,
ServiceBusFactory = mockServiceBusFactory.Object,
ContextManager = mockContextManager.Object
};
var host = fixture.Create <Uri>();
var userName = fixture.Create <string>();
var password = fixture.Create <string>();
connectionDescriptor = new MassTransitConnectionDescriptor(host, userName, password);
}
public IBusControl CreateServiceBus(MassTransitOptions options, IReadOnlyList <Action <IReceiveEndpointConfigurator> > commandSubscriptions, IReadOnlyList <Action <IReceiveEndpointConfigurator> > eventSubscriptions)
{
var bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(_connectionDescriptor.Host, h =>
{
h.Username(_connectionDescriptor.UserName);
h.Password(_connectionDescriptor.Password);
});
cfg.UseJsonSerializer();
cfg.UseConcurrencyLimit(options.ConcurrencyLimit);
if (commandSubscriptions.Any())
{
cfg.ReceiveEndpoint(host, options.CommandQueueNameStrategy.GetQueueName(), endpoint =>
{
endpoint.UseRetry(options.CommandErrorPolicy);
_rabbitMqOptions.CommandQueuePolicy.ApplyPolicy(endpoint);
foreach (var subscription in commandSubscriptions)
{
subscription(endpoint);
}
});
}
if (eventSubscriptions.Any())
{
cfg.ReceiveEndpoint(host, options.EventQueueNameStrategy.GetQueueName(), endpoint =>
{
endpoint.UseRetry(options.EventErrorPolicy);
_rabbitMqOptions.EventQueuePolicy.ApplyPolicy(endpoint);
foreach (var subscription in eventSubscriptions)
{
subscription(endpoint);
}
});
}
});
return(bus);
}
public MassTransitOption SelectedMassTransitOption()
{
if (MassTransitOptions == null)
{
throw new ArgumentNullException(nameof(MassTransitOptions));
}
if (!MassTransitOptions.Any())
{
throw new ArgumentException($"{nameof(MassTransitOptions)} is empty");
}
MassTransitOption massTransitOption = MassTransitOptions.FirstOrDefault(o => o.Index == SelectedIndex);
if (massTransitOption == null)
{
throw new ArgumentOutOfRangeException($"MassTransitOption could not found. {nameof(SelectedIndex)} : {SelectedIndex}");
}
return(massTransitOption);
}
public void MasstransitConfig(IRabbitMqBusFactoryConfigurator configurator, IContainer container, ILogger logger, IJimuBus bus, MassTransitOptions options)
{
//-- command consumer, extract queue name from command
var groupConsumers = _consumers.GroupBy(x =>
{
var commandType = x.GetTypeInfo().ImplementedInterfaces.First().GenericTypeArguments.First();
var commandInstance = container.Resolve(commandType);
if (commandInstance == null)
{
throw new Exception($"JimuCommand: {commandType.FullName} resolve failure");
}
var commandQueueName = commandInstance.GetType().InvokeMember("QueueName", BindingFlags.GetProperty, null, commandInstance, null) + "";
if (string.IsNullOrWhiteSpace(commandQueueName))
{
throw new Exception($"JimuCommand: {commandType.FullName} must specify QueueName property");
}
return(commandQueueName);
});
groupConsumers.ToList().ForEach(x =>
{
configurator.ReceiveEndpoint(x.Key, ep =>
{
logger.Debug($"MassTransitRabbitMq: CommandQueueName: { x.Key}, consumers count: {x.Count()}");
x.ToList().ForEach(consumer =>
{
var commandType = consumer.GetTypeInfo().ImplementedInterfaces.First().GenericTypeArguments.First();
var handlerMethod = typeof(HandlerExtensions).GetMethod("Handler").MakeGenericMethod(commandType);
var consumerInstance = container.Resolve(consumer);
var myHandlerObj = Activator.CreateInstance(typeof(CommandHandler <>).MakeGenericType(commandType), new object[] { consumerInstance, bus });
var consumerHandler = myHandlerObj.GetType().InvokeMember("Handler", BindingFlags.GetProperty, null, myHandlerObj, null);
var fastInvoker = FastInvoke.GetMethodInvoker(handlerMethod);
fastInvoker.Invoke(null, new object[] { ep, consumerHandler, null });
});
});
});
}
public UserService(IBus bus, MassTransitOptions options) : base(bus, options)
{
}
public void MasstransitConfig(IRabbitMqBusFactoryConfigurator configurator, IContainer container, ILogger logger, IJimuBus bus, MassTransitOptions _options)
{
if (_subscribers.Any())
{
//-- event subscriber, generate default event queue, if not specify in options
var eventQueueName = string.IsNullOrEmpty(_options.EventQueueName) ? $"{AppDomain.CurrentDomain.FriendlyName}-{Guid.NewGuid()}" : _options.EventQueueName;
configurator.ReceiveEndpoint(eventQueueName, ep =>
{
_subscribers.ForEach(subscriber =>
{
var subscriberType = subscriber.GetTypeInfo().ImplementedInterfaces.First().GenericTypeArguments.First();
var handlerMethod = typeof(HandlerExtensions).GetMethod("Handler").MakeGenericMethod(subscriberType);
var subscriberInstance = container.Resolve(subscriber);
var myHandlerObj = Activator.CreateInstance(typeof(EventHandler <>).MakeGenericType(subscriberType), new object[] { subscriberInstance, bus });
var eventHandler = myHandlerObj.GetType().InvokeMember("Handler", BindingFlags.GetProperty, null, myHandlerObj, null);
var fastInvoker = FastInvoke.GetMethodInvoker(handlerMethod);
fastInvoker.Invoke(null, new object[] { ep, eventHandler, null });
});
});
logger.Debug($"MassTransitRabbitMq: EventQueueName: { eventQueueName}, subscribers count: {_subscribers.Count()}");
}
}
public MassTransitServerModule(IConfigurationRoot jimuAppSettings) : base(jimuAppSettings)
{
_options = jimuAppSettings.GetSection(typeof(MassTransitOptions).Name).Get <MassTransitOptions>();
}
/// <summary>
/// Add the services for MassTransit according to the Threax convention. This will setup a connection to a single queue using MassTransit over RabbitMQ.
/// </summary>
/// <param name="services">The service collection to modify.</param>
/// <param name="configure">The configure callback function.</param>
/// <returns>The passed in ServiceCollection.</returns>
public static IServiceCollection AddThreaxMassTransit(this IServiceCollection services, Action <MassTransitOptions> configure = null)
{
var options = new MassTransitOptions();
configure?.Invoke(options);
services.AddMassTransit(o =>
{
var args = new Object[0];
var addConsumer = o.GetType().GetMethod(nameof(IServiceCollectionConfigurator.AddConsumer));
IEnumerable <Type> allTypes = new Type[0];
foreach (var assembly in options.AutoLoadAssemblies)
{
if (assembly != null)
{
allTypes = allTypes.Concat(assembly.ExportedTypes);
}
}
foreach (var consumer in options.Consumers)
{
var addConsumerGeneric = addConsumer.MakeGenericMethod(consumer.Type);
addConsumerGeneric.Invoke(o, args);
switch (consumer.Lifetime)
{
case Lifetime.Scoped:
services.AddScoped(consumer.Type);
break;
case Lifetime.Singleton:
services.AddSingleton(consumer.Type);
break;
case Lifetime.Transient:
services.AddTransient(consumer.Type);
break;
}
}
foreach (var consumerType in allTypes.Where(i => typeof(IConsumer).IsAssignableFrom(i) && !i.GetCustomAttributes(typeof(NoAutoDiscoverMessages), false).Any()))
{
if (!options.Consumers.Any(i => i.Type == consumerType))
{
var addConsumerGeneric = addConsumer.MakeGenericMethod(consumerType);
addConsumerGeneric.Invoke(o, args);
services.AddScoped(consumerType);
}
}
var addSaga = o.GetType().GetMethod(nameof(IServiceCollectionConfigurator.AddSaga));
foreach (var saga in options.Sagas)
{
var addSagaGeneric = addSaga.MakeGenericMethod(saga.Type);
addSagaGeneric.Invoke(o, args);
switch (saga.Lifetime)
{
case Lifetime.Scoped:
services.AddScoped(saga.Type);
break;
case Lifetime.Singleton:
services.AddSingleton(saga.Type);
break;
case Lifetime.Transient:
services.AddTransient(saga.Type);
break;
}
}
foreach (var sagaType in allTypes.Where(i => typeof(ISaga).IsAssignableFrom(i) && !i.GetCustomAttributes(typeof(NoAutoDiscoverMessages), false).Any()))
{
if (!options.Consumers.Any(i => i.Type == sagaType))
{
var addSagaGeneric = addSaga.MakeGenericMethod(sagaType);
addSagaGeneric.Invoke(o, args);
services.AddScoped(sagaType);
}
}
});
if (options.Host == "InMemory")
{
services.AddSingleton <IBusControl>(s => Bus.Factory.CreateUsingInMemory(o =>
{
if (options.OpenQueue)
{
o.ReceiveEndpoint(options.QueueName, e =>
{
e.LoadFrom(serviceProvider);
});
}
}));
}
else
{
services.AddSingleton <IBusControl>(s => Bus.Factory.CreateUsingRabbitMq(sbc =>
{
var uriBuilder = new UriBuilder(options.Host);
if (options.UseSsl)
{
uriBuilder.Port = options.SslPort;
}
var host = sbc.Host(uriBuilder.Uri, h =>
{
h.Username(options.Username);
h.Password(options.Password);
if (options.UseSsl)
{
h.UseSsl(o =>
{
o.UseCertificateAsAuthenticationIdentity = false;
o.ServerName = uriBuilder.Host;
o.Protocol = System.Security.Authentication.SslProtocols.Tls12;
options.ConfigureSsl?.Invoke(o);
});
}
});
if (options.OpenQueue)
{
sbc.ReceiveEndpoint(host, options.QueueName, e =>
{
e.LoadFrom(serviceProvider);
});
}
}));
}
services.AddSingleton <IPublishEndpoint>(s => s.GetRequiredService <IBusControl>());
services.AddTransient(typeof(IEventQueue <>), typeof(MassTransitEventQueue <>));
return(services);
}
public void MasstransitConfig(IRabbitMqBusFactoryConfigurator configurator, IContainer container, ILogger logger, IJimuBus bus, MassTransitOptions options)
{
//-- request handler, extract queue name from request
var groupHandlers = _requestHandlers.GroupBy(x =>
{
var requestType = x.GetTypeInfo().ImplementedInterfaces.First().GenericTypeArguments.First();
var requestInstance = container.Resolve(requestType);
if (requestInstance == null)
{
throw new Exception($"JimuRequest: {requestType.FullName} resolve failure");
}
var requestQueueName = requestInstance.GetType().InvokeMember("QueueName", BindingFlags.GetProperty, null, requestInstance, null) + "";
if (string.IsNullOrWhiteSpace(requestQueueName))
{
throw new Exception($"JimuRequest: {requestType.FullName} must specify QueueName property");
}
return(requestQueueName);
});
groupHandlers.ToList().ForEach(x =>
{
configurator.ReceiveEndpoint(x.Key, ep =>
{
logger.Debug($"MassTransitRabbitMq: RequestQueueName: { x.Key}, handler count: {x.Count()}");
x.ToList().ForEach(handler =>
{
var requestType = handler.GetTypeInfo().ImplementedInterfaces.First().GenericTypeArguments.First();
var respType = handler.GetTypeInfo().ImplementedInterfaces.First().GenericTypeArguments[1];
var handlerMethod = typeof(HandlerExtensions).GetMethod("Handler").MakeGenericMethod(requestType);
var requestInstance = container.Resolve(handler);
var myHandlerObj = Activator.CreateInstance(typeof(RequestHandler <,>).MakeGenericType(requestType, respType), new object[] { requestInstance, bus });
var requestHandler = myHandlerObj.GetType().InvokeMember("Handler", BindingFlags.GetProperty, null, myHandlerObj, null);
var fastInvoker = FastInvoke.GetMethodInvoker(handlerMethod);
try
{
fastInvoker.Invoke(null, new object[] { ep, requestHandler, null });
}
catch (Exception ex)
{
logger.Error($"error occure when handling RabbitMq request: {x.Key}", ex);
}
});
});
});
}
protected BaseSender(IBus bus, MassTransitOptions options)
{
Bus = bus;
MassTransitOptions = options;
}
