public async Task Should_startup_and_shut_down_cleanly()
{
var loggerFactory = new TestOutputLoggerFactory(true);
LogContext.ConfigureCurrentLogContext(loggerFactory);
DiagnosticListener.AllListeners.Subscribe(new DiagnosticListenerObserver());
var busControl = Bus.Factory.CreateUsingRabbitMq();
BusHandle handle;
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
{
handle = await busControl.StartAsync(timeout.Token);
}
try
{
await handle.Ready;
}
finally
{
await handle.StopAsync(CancellationToken.None);
}
}
public async Task Should_fault_nicely()
{
var loggerFactory = new TestOutputLoggerFactory(true);
LogContext.ConfigureCurrentLogContext(loggerFactory);
DiagnosticListener.AllListeners.Subscribe(new DiagnosticListenerObserver());
var busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
x.Host(new Uri("rabbitmq://unknownhost:32787"), h =>
{
h.Username("whocares");
h.Password("Ohcrud");
h.RequestedConnectionTimeout(2000);
});
x.AutoStart = true;
});
Assert.ThrowsAsync <RabbitMqConnectionException>(async() =>
{
BusHandle handle;
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
handle = await busControl.StartAsync(timeout.Token);
}
await handle.StopAsync(CancellationToken.None);
});
}
public static IServiceCollection AddHiveMassTransit(this IServiceCollection services,
Action <IServiceCollectionBusConfigurator>?serviceCollectionBusConfigure = null,
Action <IRegistration, IRabbitMqBusFactoryConfigurator>?configure = null)
{
_ = services.AddMassTransit(bus =>
{
serviceCollectionBusConfigure?.Invoke(bus);
bus.UsingRabbitMq((context, cfg) =>
{
LogContext.ConfigureCurrentLogContext(context.GetService <ILoggerFactory>());
var rabbitMqOptions = context.GetService <IOptions <RabbitMqOptions> >()?.Value ?? new RabbitMqOptions();
cfg.Host(new Uri(rabbitMqOptions.Url), r =>
{
r.Username(rabbitMqOptions.Username);
r.Password(rabbitMqOptions.Password);
r.Heartbeat(rabbitMqOptions.Heartbeat);
});
configure?.Invoke(context, cfg);
});
});
_ = services.AddMassTransitHostedService();
return(services);
}
public async Task TransportTestSetUp()
{
Harness = await _harnessFactory.CreateTestHarness();
if (_enableLog)
{
Harness.OnConfigureBus += cfg =>
{
LogContext.ConfigureCurrentLogContext(LoggerFactory);
LoggerFactory.Current = default;
};
}
await Harness.Clean();
await Arrange();
_fixtureContext = TestExecutionContext.CurrentContext;
LoggerFactory.Current = _fixtureContext;
await StartTestHarness();
await Task.Delay(200);
}
static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var provider = ConfigureServiceProvider();
LogContext.ConfigureCurrentLogContext(provider.GetRequiredService <ILoggerFactory>());
var bus = provider.GetRequiredService <IBusControl>();
try
{
await bus.StartAsync();
await bus.Send <DoWork>(new { });
Console.ReadKey();
}
finally
{
await bus.StopAsync();
}
}
public async Task Should_fault_nicely()
{
var loggerFactory = new TestOutputLoggerFactory(true);
LogContext.ConfigureCurrentLogContext(loggerFactory);
DiagnosticListener.AllListeners.Subscribe(new DiagnosticListenerObserver());
IBusControl busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
x.Host(new Uri("rabbitmq://unknownhost:32787"), h =>
{
h.Username("whocares");
h.Password("Ohcrud");
h.RequestedConnectionTimeout(2000);
});
x.AutoStart = false;
});
Assert.That(async() =>
{
BusHandle handle = await busControl.StartAsync(new CancellationTokenSource(20000).Token);
try
{
TestContext.Out.WriteLine("Waiting for connection...");
await handle.Ready;
}
finally
{
await handle.StopAsync();
}
}, Throws.TypeOf <RabbitMqConnectionException>());
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureServices((hostContext, services) =>
{
services.AddHostedService <Test>();
services.AddHostedService <BusService>();
services.AddSingleton <IEntityManager, LocalEntityManager>();
services.AddSingleton <IEntityResolver, EntityResolver>();
services.AddScoped <IEntityMetadataSerializer, EntityMetadataSerializer>();
services.AddMassTransit((configurator =>
{
MassTransitSetup.Setup();
configurator.SetKebabCaseEndpointNameFormatter();
configurator.AddConsumersFromNamespaceContaining <Program>();
configurator.AddInMemoryBus(((provider, factoryConfigurator) =>
{
LogContext.ConfigureCurrentLogContext(provider.GetRequiredService <ILoggerFactory>());
factoryConfigurator.ConfigureEndpoints(provider);
}));
configurator.AddRequestClient <GetEntityMetadataRequest>();
configurator.AddRequestClient <CreateEntityRequest>();
configurator.AddRequestClient <GetEntityTransformRequest>();
}));
});
public void Install(IWindsorContainer container, IConfigurationStore store)
{
// setup mass transit to log to nlog
LogContext.ConfigureCurrentLogContext(new NLogLoggerFactory());
container.Kernel.Resolver.AddSubResolver(new CollectionResolver(container.Kernel, true));
container.AddMassTransit(x =>
{
x.UsingRabbitMq((context, cfg) =>
{
cfg.Host(
"rabbitmq://" + _rabbitHost,
x =>
{
x.Username(_rabbitUser);
x.Password(_rabbitPassword);
}
);
cfg.UseSendFilter(typeof(ValidatingSendFilter <>), context);
});
});
container.Register(
Component.For <IReadOnlyCollection <IValidator> >().UsingFactoryMethod(kernel => kernel.ResolveAll <IValidator>().ToArray()).LifestyleSingleton()
);
// to recieve messages we have to start bus (this includes receiving responses).
container.Resolve <IBusControl>().Start();
}
public static void AddMassTransitBus(this IServiceCollection services, RabbitMqSettings rabbitMqSettings,
Action <IRabbitMqBusFactoryConfigurator, IRabbitMqHost> registrationAction = null)
{
var serviceProvider = services.BuildServiceProvider();
// Handle Logging
var loggerFactory = serviceProvider.GetRequiredService <ILoggerFactory>();
LogContext.ConfigureCurrentLogContext(loggerFactory);
// Configure Bus
var bus = ConfigureBus(rabbitMqSettings, registrationAction);
// Register Interfaces
services.AddSingleton <IPublishEndpoint>(bus);
services.AddSingleton <ISendEndpointProvider>(bus);
services.AddSingleton <IBus>(bus);
services.AddSingleton <IBusControl>(bus);
try
{
bus.Start();
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger(nameof(AddMassTransitBus));
logger?.LogError($"Bus could not started. Error: {ex.Message}, StackTrace: {ex.StackTrace}");
}
}
public async Task Should_not_be_allowed_twice()
{
var loggerFactory = new TestOutputLoggerFactory(true);
LogContext.ConfigureCurrentLogContext(loggerFactory);
DiagnosticListener.AllListeners.Subscribe(new DiagnosticListenerObserver());
var secondHarness = new RabbitMqTestHarness();
try
{
Assert.That(async() =>
{
using (var token = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
await secondHarness.Start(token.Token).OrCanceled(TestCancellationToken);
await secondHarness.Stop();
}
}, Throws.TypeOf <RabbitMqConnectionException>());
}
finally
{
secondHarness.Dispose();
}
}
protected IBusInstance CreateBus <T, TConfigurator>(T configurator, IBusRegistrationContext context,
Action <IBusRegistrationContext, TConfigurator> configure, IEnumerable <IBusInstanceSpecification> specifications)
where T : TConfigurator, IBusFactory
where TConfigurator : IBusFactoryConfigurator
{
var loggerFactory = context.GetService <ILoggerFactory>();
if (loggerFactory != null)
{
LogContext.ConfigureCurrentLogContext(loggerFactory);
}
context.UseHealthCheck(configurator);
var riders = new RiderConnectable();
configurator.ConnectBusObserver(new RiderBusObserver(riders));
configure?.Invoke(context, configurator);
specifications ??= Enumerable.Empty <IBusInstanceSpecification>();
var busControl = configurator.Build(specifications);
var instance = new TransportBusInstance(busControl, _hostConfiguration, riders);
foreach (var specification in specifications)
{
specification.Configure(instance);
}
return(instance);
}
void ConfigureLogging()
{
var loggerFactory = Provider.GetRequiredService <ILoggerFactory>();
LogContext.ConfigureCurrentLogContext(loggerFactory);
Quartz.Logging.LogContext.SetCurrentLogProvider(loggerFactory);
}
protected void ConfigureLogging(ILogger logger)
{
var loggerFactory = new TestOutputLoggerFactory(true, logger);
LogContext.ConfigureCurrentLogContext(loggerFactory);
Quartz.Logging.LogContext.SetCurrentLogProvider(loggerFactory);
}
public static IApplicationBuilder UseCustomMassTransit(this IApplicationBuilder app)
{
var loggerFactory = app.ApplicationServices.GetService <LoggerFactory>();
LogContext.ConfigureCurrentLogContext(loggerFactory);
return(app);
}
protected virtual void ConfigureLogging(ILoggerFactory loggerFactory)
{
// masstransit의 logging이 test용 logger factory 를 사용하도록 지정.
LogContext.ConfigureCurrentLogContext(loggerFactory);
// Quartz 의 logging이 test용 logger factory 를 사용하도록 지정.
Quartz.Logging.LogContext.SetCurrentLogProvider(loggerFactory);
}
protected override void Register(ContainerBuilder builder)
{
builder.RegisterMetadataRegistrationSources();
builder.RegisterModule <Cogito.Autofac.AssemblyModule>();
builder.RegisterFromAttributes(typeof(AssemblyModule).Assembly);
// setup global logging
builder.RegisterBuildCallback(i => LogContext.ConfigureCurrentLogContext(i.Resolve <Microsoft.Extensions.Logging.ILoggerFactory>()));
// standard Autofac related services
builder.RegisterType <BusDepot>().As <IBusDepot>().SingleInstance();
builder.Register(CreateConsumerScopeProvider).As <IConsumerScopeProvider>().SingleInstance().IfNotRegistered(typeof(IConsumerScopeProvider));
builder.Register(GetCurrentSendEndpointProvider).As <ISendEndpointProvider>().InstancePerLifetimeScope();
builder.Register(GetCurrentPublishEndpoint).As <IPublishEndpoint>().InstancePerLifetimeScope();
builder.Register(context => new AutofacConfigurationServiceProvider(context.Resolve <ILifetimeScope>())).As <IConfigurationServiceProvider>().SingleInstance().IfNotRegistered(typeof(IConfigurationServiceProvider));
// consumer related services
builder.RegisterType <ConsumerDefinitionProvider>().SingleInstance();
builder.RegisterType <ConsumerDefinitionReceiveEndpointConfigurationSource>().As <IReceiveEndpointConfigurationSource>().SingleInstance();
builder.RegisterType <ConsumerDefinitionNameSource>().As <IBusNameSource>().As <IReceiveEndpointNameSource>().SingleInstance();
builder.RegisterType <ContainerConsumerDefinitionSource>().As <IConsumerDefinitionSource>().SingleInstance();
// saga related services
builder.RegisterType <SagaDefinitionProvider>().SingleInstance();
builder.RegisterType <SagaDefinitionReceiveEndpointConfigurationSource>().As <IReceiveEndpointConfigurationSource>().SingleInstance();
builder.RegisterType <SagaDefinitionNameSource>().As <IBusNameSource>().As <IReceiveEndpointNameSource>().SingleInstance();
builder.RegisterType <ContainerSagaDefinitionSource>().As <ISagaDefinitionSource>().SingleInstance();
// saga state machine related services
builder.RegisterType <SagaStateMachineDefinitionProvider>().SingleInstance();
builder.RegisterType <SagaStateMachineDefinitionReceiveEndpointConfigurationSource>().As <IReceiveEndpointConfigurationSource>().SingleInstance();
builder.RegisterType <SagaStateMachineDefinitionNameSource>().As <IBusNameSource>().As <IReceiveEndpointNameSource>().SingleInstance();
builder.RegisterType <ContainerSagaStateMachineDefinitionSource>().As <ISagaStateMachineDefinitionSource>().SingleInstance();
// bus related services
builder.RegisterType <ContainerBusConfigurationSource>().As <IBusConfigurationSource>().SingleInstance();
builder.RegisterType <ContainerBusObserverConfiguration>().As <IBusConfiguration>().SingleInstance();
builder.RegisterType <ContainerBusReceiveEndpointConfiguration>().As <IBusConfiguration>().SingleInstance();
builder.RegisterType <ContainerBusDefinitionSource>().As <IBusDefinitionSource>().SingleInstance();
// providers
builder.RegisterType <BusDefinitionNameSource>().As <IBusNameSource>().SingleInstance();
builder.RegisterType <BusDefinitionProvider>().SingleInstance();
builder.RegisterType <BusNameProvider>().SingleInstance();
builder.RegisterType <BusConfigurationProvider>().SingleInstance();
builder.RegisterType <ReceiveEndpointNameProvider>().SingleInstance();
builder.RegisterType <ReceiveEndpointConfigurationProvider>().SingleInstance();
builder.RegisterType <BusRegistrationFactory>().SingleInstance();
builder.RegisterType <BusProvider>().SingleInstance();
// generates request clients
builder.RegisterGenericRequestClient();
// register default bus instance
builder.Register(ctx => ctx.Resolve <BusProvider>().GetBus()).SingleInstance().ExternallyOwned().As <IBusControl>().As <IBus>();
builder.Register(ctx => ctx.Resolve <IBus>().CreateClientFactory()).SingleInstance();
}
protected virtual void ConfigureMediator(IMediatorConfigurator mediatorConfigurator)
{
if (_enableLog)
{
LogContext.ConfigureCurrentLogContext(LoggerFactory);
}
LoggerFactory.Current = default;
}
protected IBusInstance CreateBus <T, TConfigurator>(T configurator, IBusRegistrationContext context,
Action <IBusRegistrationContext, TConfigurator> configure, IEnumerable <IBusInstanceSpecification> specifications)
where T : TConfigurator, IBusFactory
where TConfigurator : IBusFactoryConfigurator
{
var loggerFactory = context.GetService <ILoggerFactory>();
if (loggerFactory != null)
{
LogContext.ConfigureCurrentLogContext(loggerFactory);
}
else if (LogContext.Current == null)
{
LogContext.ConfigureCurrentLogContext();
}
_hostConfiguration.LogContext = LogContext.Current;
context.UseHealthCheck(configurator);
configure?.Invoke(context, configurator);
specifications ??= Enumerable.Empty <IBusInstanceSpecification>();
IEnumerable <IBusInstanceSpecification> busInstanceSpecifications = specifications as IBusInstanceSpecification[] ?? specifications.ToArray();
IEnumerable <ValidationResult> validationResult = configurator.Validate()
.Concat(busInstanceSpecifications.SelectMany(x => x.Validate()));
var result = BusConfigurationResult.CompileResults(validationResult);
try
{
var busReceiveEndpointConfiguration = configurator.CreateBusEndpointConfiguration(x => x.ConfigureConsumeTopology = false);
var host = _hostConfiguration.Build() as IHost <TEndpointConfigurator>;
var bus = new MassTransitBus(host, _hostConfiguration.BusConfiguration.BusObservers, busReceiveEndpointConfiguration);
TaskUtil.Await(() => _hostConfiguration.BusConfiguration.BusObservers.PostCreate(bus));
IBusInstance instance = CreateBusInstance(bus, host, _hostConfiguration, context);
foreach (var specification in busInstanceSpecifications)
{
specification.Configure(instance);
}
return(instance);
}
catch (Exception ex)
{
TaskUtil.Await(() => _hostConfiguration.BusConfiguration.BusObservers.CreateFaulted(ex));
throw new ConfigurationException(result, "An exception occurred during bus creation", ex);
}
}
#pragma warning disable IDE0060 // Supprimer le paramètre inutilisé
private static void ConfigureLogging(IConfiguration configuration, LoggerConfiguration loggerConfiguration)
{
loggerConfiguration.WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss.fff} {SourceContext}]{NewLine}[{Level}]{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}")
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft.EntityFrameworkCore", Serilog.Events.LogEventLevel.Error);
Serilog.Debugging.SelfLog.Enable(Console.Error);
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
LogContext.ConfigureCurrentLogContext();
}
protected static void ConfigureLogContext(IConfigurationServiceProvider provider)
{
var loggerFactory = provider.GetService <ILoggerFactory>();
if (loggerFactory != null)
{
LogContext.ConfigureCurrentLogContext(loggerFactory);
}
}
public static void SetupMassTransitLogger()
{
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Information()
.WriteTo.Console()
.CreateLogger();
LogContext.ConfigureCurrentLogContext(new SerilogLoggerFactory());
}
protected ReceiverConfiguration(IEndpointConfiguration endpointConfiguration)
: base(endpointConfiguration)
{
Specifications = new List <IReceiveEndpointSpecification>();
if (LogContext.Current == null)
{
LogContext.ConfigureCurrentLogContext();
}
}
public static void Main(string[] args)
{
var logger = LoggingConfiguration.ConfigureLogger("PricingProxy");
LogContext.ConfigureCurrentLogContext(new SerilogLoggerFactory(logger));
var bus = ConfigureBus();
bus.Start();
CreateWebHostBuilder(args).Build().Run();
}
protected BusFactoryConfigurator(IBusConfiguration busConfiguration)
{
_busConfiguration = busConfiguration;
busConfiguration.BusEndpointConfiguration.Consume.Configurator.AutoStart = false;
if (LogContext.Current == null)
{
LogContext.ConfigureCurrentLogContext();
}
}
public override IMessageBus GetBusInstance()
{
LogContext.ConfigureCurrentLogContext(LoggerFactory);
Logger.LogInformation("MessageBus:Use {TransportType} Transport", Options.Transport);
IBusControl busControl = BuildBusControl();
busControl.Start();
Logger.LogInformation($"MessageBus:Started");
return(new MassTransitMessageBus(busControl, Options));
}
public static async Task Main()
{
var config = new MTASBSettings
{
MaxConcurrentCalls = 100,
Endpoint = "sb://endpoint.servicebus.windows.net",
KeyName = "RootManageSharedAccessKey",
SharedAccessSignature = "setme",
PublishInterval = 5000
};
var loggerFactory = new ServiceCollection()
.AddLogging(loggingOptions => loggingOptions.AddConsole().SetMinimumLevel(LogLevel.Trace).AddFile(@"C:\logs\repro.mt.{Date}.log", minimumLevel: LogLevel.Trace))
.BuildServiceProvider()
.GetRequiredService <ILoggerFactory>();
LogContext.ConfigureCurrentLogContext(loggerFactory);
var busControl = Bus.Factory.CreateUsingAzureServiceBus(busConfigurator =>
{
busConfigurator.Host(config.Endpoint, hostConfig =>
{
hostConfig.SharedAccessSignature(sasConfig =>
{
sasConfig.KeyName = config.KeyName;
sasConfig.SharedAccessKey = config.SharedAccessSignature;
sasConfig.TokenTimeToLive = TimeSpan.FromDays(1);
});
});
busConfigurator.ReceiveEndpoint("repro.project.mass.transit.queue", ep =>
{
ep.MaxConcurrentCalls = config.MaxConcurrentCalls;
ep.LockDuration = TimeSpan.FromMinutes(1);
ep.Consumer <Consumer>(() => new Consumer(loggerFactory.CreateLogger <Consumer>()));
});
});
await busControl.StartAsync();
var publisher = new Publisher(busControl, loggerFactory.CreateLogger <Publisher>());
var timer = new System.Timers.Timer(config.PublishInterval);
timer.Elapsed += publisher.Publish;
timer.Start();
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
timer.Stop();
await busControl.StopAsync();
}
void ConfigureBus(IBusFactoryConfigurator configurator)
{
var loggerFactory = new TestOutputLoggerFactory(true);
LogContext.ConfigureCurrentLogContext(loggerFactory);
if (Interlocked.CompareExchange(ref _subscribedObserver, 1, 0) == 0)
{
DiagnosticListener.AllListeners.Subscribe(new DiagnosticListenerObserver());
}
}
public MediatorConfiguration(IHostConfiguration hostConfiguration, IReceiveEndpointConfiguration endpointConfiguration)
: base(hostConfiguration, endpointConfiguration)
{
_hostConfiguration = hostConfiguration;
if (_hostConfiguration.LogContext == null)
{
LogContext.ConfigureCurrentLogContext();
_hostConfiguration.LogContext = LogContext.Current;
}
}
public static void ConfigureBusDiagnostics(IBusFactoryConfigurator configurator)
{
LogContext.ConfigureCurrentLogContext(LoggerFactory);
if (_enableDiagnostics)
{
if (Interlocked.CompareExchange(ref _subscribedObserver, 1, 0) == 0)
{
DiagnosticListener.AllListeners.Subscribe(new DiagnosticListenerObserver());
}
}
}
protected void ConfigureRegistration(IMediatorRegistrationConfigurator configurator)
{
configurator.AddConsumer <PingConsumer>();
configurator.AddRequestClient <Ping>();
configurator.ConfigureMediator((context, cfg) =>
{
LogContext.ConfigureCurrentLogContext(LoggerFactory);
ConfigureFilters(context, cfg);
});
}
