/// <summary>
/// Adds the specified saga types
/// </summary>
/// <param name="configurator"></param>
/// <param name="types">The state machine types to add</param>
public static void AddSagas(this IRegistrationConfigurator configurator, params Type[] types)
{
IEnumerable <Type> sagaTypes = types.Where(x => x.HasInterface <ISaga>() && !x.HasInterface <SagaStateMachineInstance>());
IEnumerable <Type> sagaDefinitionTypes = types.Where(x => x.HasInterface(typeof(ISagaDefinition <>)));
var sagas = from c in sagaTypes
join d in sagaDefinitionTypes on c equals d.GetClosingArgument(typeof(ISagaDefinition <>)) into dc
from d in dc.DefaultIfEmpty()
select new
{
SagaType = c,
DefinitionType = d
};
foreach (var saga in sagas)
{
configurator.AddSaga(saga.SagaType, saga.DefinitionType);
}
}
/// <summary>
/// Adds the specified consumer types
/// </summary>
/// <param name="configurator"></param>ˆ
/// <param name="types">The state machine types to add</param>
public static void AddConsumers(this IRegistrationConfigurator configurator, params Type[] types)
{
IEnumerable <Type> consumerTypes = types.Where(TypeMetadataCache.HasConsumerInterfaces);
IEnumerable <Type> consumerDefinitionTypes = types.Where(x => x.HasInterface(typeof(IConsumerDefinition <>)));
var consumers = from c in consumerTypes
join d in consumerDefinitionTypes on c equals d.GetClosingArgument(typeof(IConsumerDefinition <>)) into dc
from d in dc.DefaultIfEmpty()
select new
{
ConsumerType = c,
DefinitionType = d
};
foreach (var consumer in consumers)
{
configurator.AddConsumer(consumer.ConsumerType, consumer.DefinitionType);
}
}
static void AddBus(this IRegistrationConfigurator <IServiceProvider> configurator, Action <IServiceBusBusFactoryConfigurator> configure = null)
{
configurator.AddBus(context =>
{
IOptions <ServiceBusOptions> options = context.Container.GetRequiredService <IOptions <ServiceBusOptions> >();
options.Value.MessageHandlerOptions.AutoComplete = true;
IServiceBusBusConfiguration busConfiguration = context.Container.GetRequiredService <IServiceBusBusConfiguration>();
var busFactoryConfigurator = new ServiceBusBusFactoryConfigurator(busConfiguration);
busFactoryConfigurator.Host(options.Value.ConnectionString);
busFactoryConfigurator.UseServiceBusMessageScheduler();
configure?.Invoke(busFactoryConfigurator);
return(busFactoryConfigurator.Build());
});
}
protected void ConfigureRegistration <T>(IRegistrationConfigurator <T> configurator)
{
configurator.AddSagaStateMachine <TestStateMachineSaga, TestInstance>()
.EntityFrameworkRepository(r =>
{
r.AddDbContext <DbContext, TestInstanceDbContext>(ApplyBuilderOptions);
r.ConcurrencyMode = ConcurrencyMode.Pessimistic;
if (DbContextOptionsBuilder.Options.Extensions.Any(x => x is NpgsqlOptionsExtension))
{
r.LockStatementProvider = new PostgresLockStatementProvider(false);
}
else
{
r.LockStatementProvider = new SqlServerLockStatementProvider(false);
}
});
configurator.AddBus(provider => BusControl);
}
/// <summary>
/// Adds the specified consumer types which match the given filter
/// </summary>
/// <param name="configurator"></param>
/// <param name="filter"></param>
/// <param name="types">The consumer types to add</param>
public static void AddFutures(this IRegistrationConfigurator configurator, Func <Type, bool> filter, params Type[] types)
{
filter ??= t => true;
IEnumerable <Type> consumerTypes = types.Where(x => x.HasInterface(typeof(SagaStateMachine <FutureState>)));
IEnumerable <Type> consumerDefinitionTypes = types.Where(x => x.HasInterface(typeof(IFutureDefinition <>)));
var futures = from c in consumerTypes
join d in consumerDefinitionTypes on c equals d.GetClosingArgument(typeof(IFutureDefinition <>)) into dc
from d in dc.DefaultIfEmpty()
where filter(c)
select new
{
FutureType = c,
DefinitionType = d
};
foreach (var future in futures)
{
configurator.AddFuture(future.FutureType, future.DefinitionType);
}
}
/// <summary>
/// Adds the specified activity types
/// </summary>
/// <param name="configurator"></param>
/// <param name="types">The state machine types to add</param>
public static void AddActivities(this IRegistrationConfigurator configurator, params Type[] types)
{
IEnumerable <Type> activityTypes = types.Where(x => x.HasInterface(typeof(IActivity <,>))).ToList();
IEnumerable <Type> activityDefinitionTypes = types.Where(x => x.HasInterface(typeof(IActivityDefinition <, ,>))).ToList();
var activities = from c in activityTypes
join d in activityDefinitionTypes on c equals d.GetClosingArguments(typeof(IActivityDefinition <, ,>)).First() into dc
from d in dc.DefaultIfEmpty()
select new
{
ActivityType = c,
DefinitionType = d
};
foreach (var activity in activities)
{
configurator.AddActivity(activity.ActivityType, activity.DefinitionType);
}
IEnumerable <Type> executeActivityTypes = types.Where(x => x.HasInterface(typeof(IExecuteActivity <>))).Except(activityTypes).ToList();
IEnumerable <Type> executeActivityDefinitionTypes = types.Where(x => x.HasInterface(typeof(IExecuteActivityDefinition <,>))).ToList();
var executeActivities = from c in executeActivityTypes
join d in executeActivityDefinitionTypes on c equals d.GetClosingArguments(typeof(IExecuteActivityDefinition <,>)).First() into dc
from d in dc.DefaultIfEmpty()
select new
{
ActivityType = c,
DefinitionType = d
};
foreach (var executeActivity in executeActivities)
{
configurator.AddExecuteActivity(executeActivity.ActivityType, executeActivity.DefinitionType);
}
}
/// <summary>
/// Adds the consumer, allowing configuration when it is configured on an endpoint
/// </summary>
/// <param name="configurator"></param>
/// <param name="configure"></param>
/// <typeparam name="T">The consumer type</typeparam>
/// <typeparam name="TDefinition">The consumer definition type</typeparam>
public static IConsumerRegistrationConfigurator <T> AddConsumer <T, TDefinition>(this IRegistrationConfigurator configurator,
Action <IConsumerConfigurator <T> > configure = null)
where T : class, IConsumer
where TDefinition : class, IConsumerDefinition <T>
{
return(configurator.AddConsumer(typeof(TDefinition), configure));
}
/// <summary>
/// Adds a SagaStateMachine to the registry, using the factory method, and updates the registrar prior to registering so that the default
/// saga registrar isn't notified.
/// </summary>
/// <param name="configurator"></param>
/// <param name="registrar"></param>
/// <param name="sagaDefinitionType"></param>
/// <typeparam name="TStateMachine"></typeparam>
/// <typeparam name="TInstance"></typeparam>
public static ISagaRegistrationConfigurator <TInstance> AddSagaStateMachine <TStateMachine, TInstance>(this IRegistrationConfigurator configurator,
ISagaStateMachineRegistrar registrar, Type sagaDefinitionType = null)
where TStateMachine : class, SagaStateMachine <TInstance>
where TInstance : class, SagaStateMachineInstance
{
ISagaRegistration Factory(IContainerRegistrar containerRegistrar)
{
SagaStateMachineRegistrationCache.Register(typeof(TStateMachine), registrar);
if (sagaDefinitionType != null)
{
SagaDefinitionRegistrationCache.Register(sagaDefinitionType, containerRegistrar);
}
return(new SagaStateMachineRegistration <TInstance>());
}
return(configurator.AddSaga <TInstance>(Factory));
}
/// <summary>
/// Adds a SagaStateMachine to the registry and updates the registrar prior to registering so that the default
/// saga registrar isn't notified.
/// </summary>
/// <param name="configurator"></param>
/// <param name="configure"></param>
/// <typeparam name="TStateMachine">The state machine type</typeparam>
/// <typeparam name="T">The state machine instance type</typeparam>
/// <typeparam name="TDefinition">The saga definition type</typeparam>
public static ISagaRegistrationConfigurator <T> AddSagaStateMachine <TStateMachine, T, TDefinition>(this IRegistrationConfigurator configurator,
Action <ISagaConfigurator <T> > configure = null)
where T : class, SagaStateMachineInstance
where TStateMachine : class, SagaStateMachine <T>
where TDefinition : class, ISagaDefinition <T>
{
return(configurator.AddSagaStateMachine <TStateMachine, T>(typeof(TDefinition), configure));
}
/// <summary>
/// Adds the specified consumer types
/// </summary>
/// <param name="configurator"></param>
/// ˆ
/// <param name="types">The state machine types to add</param>
public static void AddFutures(this IRegistrationConfigurator configurator, params Type[] types)
{
AddFutures(configurator, null, types);
}
public ConsumerRegistrationConfigurator(IRegistrationConfigurator configurator, IConsumerRegistration registration, IContainerRegistrar registrar)
{
_configurator = configurator;
_registration = registration;
_registrar = registrar;
}
/// <summary>
/// Create EntityFramework saga repository
/// </summary>
/// <param name="registrationConfigurator"></param>
/// <param name="configure"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static IEntityFrameworkSagaRepository CreateEntityFrameworkSagaRepository(this IRegistrationConfigurator registrationConfigurator,
Action <DbContextOptionsBuilder> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var optionsBuilder = EntityFrameworkSagaRepository.CreateOptionsBuilder();
configure(optionsBuilder);
return(new EntityFrameworkSagaRepository(optionsBuilder.Options));
}
/// <summary>
/// Adds all futures in the specified assemblies
/// </summary>
/// <param name="configurator"></param>
/// <param name="assemblies">The assemblies to scan for futures</param>
public static void AddFutures(this IRegistrationConfigurator configurator, params Assembly[] assemblies)
{
AddFutures(configurator, null, assemblies);
}
/// <summary>
/// Use the Dapper saga repository for sagas configured by type (without a specific generic call to AddSaga/AddSagaStateMachine)
/// </summary>
/// <param name="configurator"></param>
/// <param name="connectionString"></param>
/// <param name="configure"></param>
public static void SetDapperSagaRepositoryProvider(this IRegistrationConfigurator configurator, string connectionString,
Action <IDapperSagaRepositoryConfigurator> configure)
{
configurator.SetSagaRepositoryProvider(new DapperSagaRepositoryRegistrationProvider(connectionString, configure));
}
public IConsumerRegistrationConfigurator GetConsumerRegistrationConfigurator(IRegistrationConfigurator registrationConfigurator)
{
return(new ConsumerRegistrationConfigurator <TConsumer>(registrationConfigurator));
}
/// <summary>
/// Use the Cosmos saga repository for sagas configured by type (without a specific generic call to AddSaga/AddSagaStateMachine)
/// </summary>
/// <param name="configurator"></param>
/// <param name="configure"></param>
public static void SetCosmosSagaRepositoryProvider(this IRegistrationConfigurator configurator, Action <ICosmosSagaRepositoryConfigurator> configure)
{
configurator.SetSagaRepositoryProvider(new CosmosSagaRepositoryRegistrationProvider(configure));
}
/// <summary>
/// Add a <see cref="IMessageScheduler" /> to the container that uses the ActiveMQ scheduler
/// </summary>
/// <param name="configurator"></param>
public static void AddActiveMqMessageScheduler(this IRegistrationConfigurator configurator)
{
configurator.AddMessageScheduler(new MessageSchedulerRegistration());
}
protected static void ConfigureRegistration(IRegistrationConfigurator configurator)
{
configurator.AddConsumer <RequestConsumer>();
configurator.AddRequestClient <Request>();
}
/// <summary>
/// Configure the Kebab Case endpoint name formatter
/// </summary>
/// <param name="configurator"></param>
public static void SetKebabCaseEndpointNameFormatter(this IRegistrationConfigurator configurator)
{
configurator.SetEndpointNameFormatter(KebabCaseEndpointNameFormatter.Instance);
}
protected void ConfigureRegistration <T>(IRegistrationConfigurator <T> configurator)
where T : class
{
configurator.AddConsumer <DependentConsumer>();
configurator.AddBus(provider => BusControl);
}
/// <summary>
/// Adds the consumer, allowing configuration when it is configured on an endpoint
/// </summary>
/// <param name="configurator"></param>
/// <typeparam name="T">The consumer type</typeparam>
/// <typeparam name="TDefinition">The consumer definition type</typeparam>
public static IFutureRegistrationConfigurator <T> AddFuture <T, TDefinition>(this IRegistrationConfigurator configurator)
where T : MassTransitStateMachine <FutureState>
where TDefinition : class, IFutureDefinition <T>
{
return(configurator.AddFuture <T>(typeof(TDefinition)));
}
/// <summary>
/// Add consumers that were already added to the container to the registration
/// </summary>
public static void AddConsumersFromContainer(this IRegistrationConfigurator configurator, IContainer container)
{
var consumerTypes = container.FindTypes(TypeMetadataCache.IsConsumerOrDefinition);
configurator.AddConsumers(consumerTypes);
}
/// <summary>
/// Adds all consumers from the assembly containing the specified type that are in the same (or deeper) namespace.
/// </summary>
/// <param name="configurator"></param>
/// <param name="filter"></param>
/// <typeparam name="T">The anchor type</typeparam>
public static void AddConsumersFromNamespaceContaining <T>(this IRegistrationConfigurator configurator, Func <Type, bool> filter = null)
{
AddConsumersFromNamespaceContaining(configurator, typeof(T), filter);
}
/// <summary>
/// Add sagas that were already added to the container to the registration
/// </summary>
public static void AddSagasFromContainer(this IRegistrationConfigurator configurator, IComponentContext context)
{
Type[] sagaTypes = context.FindTypes(TypeMetadataCache.IsSagaOrDefinition);
configurator.AddSagas(sagaTypes);
}
/// <summary>
/// Use the EntityFramework saga repository for sagas configured by type (without a specific generic call to AddSaga/AddSagaStateMachine)
/// </summary>
/// <param name="configurator"></param>
/// <param name="configure"></param>
public static void SetEntityFrameworkSagaRepositoryProvider(this IRegistrationConfigurator configurator,
Action <IEntityFrameworkSagaRepositoryConfigurator> configure)
{
configurator.SetSagaRepositoryProvider(new EntityFrameworkSagaRepositoryRegistrationProvider(configure));
}
static void AddConsumer(this IRegistrationConfigurator rider)
{
rider.AddConsumer <StockConfirmationConsumer>();
rider.AddConsumer <StockConfirmationFailConsumer>();
rider.AddConsumer <BuyerCreatedConsumer>();
}
public SagaRegistrationConfigurator(IRegistrationConfigurator configurator, IContainerRegistrar registrar)
{
_configurator = configurator;
_registrar = registrar;
}
public ActivityRegistrationConfigurator(IRegistrationConfigurator configurator)
{
_configurator = configurator;
}
/// <summary>
/// Add sagas that were already added to the container to the registration
/// </summary>
public static void AddSagasFromContainer(this IRegistrationConfigurator configurator, IContainer container)
{
var sagaTypes = container.FindTypes(TypeMetadataCache.IsSagaOrDefinition);
configurator.AddSagas(sagaTypes);
}
public static void AddAmazonSqsMessageScheduler(this IRegistrationConfigurator configurator)
{
configurator.AddDelayedMessageScheduler();
}
