private static async Task ConfigureRabbitMQAsync(IServiceCollection services, CancellationToken cancellationToken = default)
{
IBusControl bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
ServiceProvider sp = services.BuildServiceProvider();
IOptions <RabbitMQConfiguration> rabbitConfig = sp.GetService <IOptions <RabbitMQConfiguration> >();
var _logger = sp.GetService <ILogger <Program> >();
_logger.LogInformation($"Connected to rabbit host: {rabbitConfig.Value.Hostname}{rabbitConfig.Value.VirtualHost}:{rabbitConfig.Value.Port}");
MassTransit.RabbitMqTransport.IRabbitMqHost host = cfg.Host(rabbitConfig.Value.Hostname, rabbitConfig.Value.Port, rabbitConfig.Value.VirtualHost, h =>
{
h.Username(rabbitConfig.Value.Username);
h.Password(rabbitConfig.Value.Password);
});
cfg.ExchangeType = ExchangeType.Fanout;
cfg.ReceiveEndpoint(host, ep =>
{
ep.UseCircuitBreaker(cb =>
{
cb.TrackingPeriod = TimeSpan.FromMinutes(1);
cb.TripThreshold = 15;
cb.ActiveThreshold = 10;
cb.ResetInterval = TimeSpan.FromMinutes(5);
});
ep.UseRateLimit(1000, TimeSpan.FromSeconds(5));
ep.Handler <DiffPlaylistEvent>(async context =>
{
Console.ForegroundColor = ConsoleColor.Green;
await Console.Out.WriteLineAsync($"{nameof(DiffPlaylistEvent)}: {context.Message}").ConfigureAwait(false);
Console.ResetColor();
});
ep.Handler <TraceEvent>(async context =>
{
Console.ForegroundColor = ConsoleColor.Yellow;
await Console.Out.WriteLineAsync($"{nameof(TraceEvent)}: {context.Message}").ConfigureAwait(false);
Console.ResetColor();
});
//Note: do no use sp variable
ep.Consumer(() => services.BuildServiceProvider().GetService <RabbitNotificationConsumer>());
ep.Consumer(() => services.BuildServiceProvider().GetService <RabbitSynchronizeConsumer>());
ep.Consumer(() => services.BuildServiceProvider().GetService <FirebaseNotificationConsumer>());
});
});
services.AddSingleton <IPublishEndpoint>(bus);
services.AddSingleton <ISendEndpointProvider>(bus);
services.AddSingleton <IBusControl>(bus);
services.AddSingleton <IBus>(bus);
services.AddScoped <IHostedService, MassTransitHostedService>();
await Task.CompletedTask;
}
public static void AddRabbitMq(this IServiceCollection services)
{
//services.AddScoped<DiffPlaylistConsumer>();
//services.AddScoped<TraceConsumer>();
services.AddMassTransit(x =>
{
// x.AddConsumer<DiffPlaylistConsumer>();
// x.AddConsumer<TraceConsumer>();
});
services.AddSingleton(provider => Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IOptions <RabbitMQConfiguration> rabbitConfig = Startup.Provider.GetService <IOptions <RabbitMQConfiguration> >();
ILoggerFactory _loggerFactory = Startup.Provider.GetService <ILoggerFactory>();
ILogger _logger = _loggerFactory.CreateLogger(typeof(Startup));
_logger.LogInformation($"Connected to rabbit host: {rabbitConfig.Value.Hostname}{rabbitConfig.Value.VirtualHost}:{rabbitConfig.Value.Port}");
MassTransit.RabbitMqTransport.IRabbitMqHost host = cfg.Host(rabbitConfig.Value.Hostname, rabbitConfig.Value.Port, rabbitConfig.Value.VirtualHost, h =>
{
h.Username(rabbitConfig.Value.Username);
h.Password(rabbitConfig.Value.Password);
});
cfg.ExchangeType = ExchangeType.Fanout;
cfg.ReceiveEndpoint(host, ep =>
{
ep.UseCircuitBreaker(cb =>
{
cb.TrackingPeriod = TimeSpan.FromMinutes(1);
cb.TripThreshold = 15;
cb.ActiveThreshold = 10;
cb.ResetInterval = TimeSpan.FromMinutes(5);
});
ep.UseRateLimit(1000, TimeSpan.FromSeconds(5));
ep.LoadFrom(Startup.Provider);
});
}));
services.AddSingleton <IPublishEndpoint>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <ISendEndpointProvider>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <IBus>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <IHostedService, MassTransitHostedService>();
}
/// <summary>
///
/// </summary>
/// <param name="services"></param>
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddOptions();
RabbitMQOptions rabbitMqOptions = new RabbitMQOptions();
Configuration.GetSection("RABBITMQOPTIONS").Bind(rabbitMqOptions);
services.AddAutoMapperSetup();
services.AddDbContext <FavoDeMelContext>(options =>
options
.UseSqlServer(Configuration.GetConnectionString("FAVODEMEL_CONNECTION_STRING"))
.UseLazyLoadingProxies());
services.AddTransient <ISqlConnectionFactory>(c => new SqlConnectionFactory(Configuration.GetConnectionString("FAVODEMEL_CONNECTION_STRING")));
services.AddSingleton(provider => Bus.Factory.CreateUsingRabbitMq(cfg =>
{
Uri hostAddress = new Uri(rabbitMqOptions.Host);
MassTransit.RabbitMqTransport.IRabbitMqHost hostRabbit = cfg.Host(hostAddress, h =>
{
h.Username(rabbitMqOptions.User);
h.Password(rabbitMqOptions.Password);
});
cfg.UseConcurrencyLimit(1);
}));
services.AddSingleton <IPublishEndpoint>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <ISendEndpointProvider>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <IBus>(provider => provider.GetRequiredService <IBusControl>());
services.Configure <CookiePolicyOptions>(options =>
{
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddCors(options =>
{
options.AddPolicy("AllowOrigin",
builder => builder.WithOrigins("http://*****:*****@localhost:5672", name: "rabbitMQ")
.AddSqlServer(connectionString: Configuration.GetConnectionString("FAVODEMEL_CONNECTION_STRING"));
services.AddHealthChecksUI();
services.AddMediatR(typeof(Startup));
services.AddDependencyInjectionSetup();
}
private static void SetUpConsumers(SubscriberParams argOptions, MassTransit.RabbitMqTransport.IRabbitMqBusFactoryConfigurator sbc, MassTransit.RabbitMqTransport.IRabbitMqHost host)
{
//sbc.UseInMemoryScheduler();
sbc.UseMessageScheduler(new Uri($"rabbitmq://{argOptions.Host}/quartz"));
sbc.ReceiveEndpoint(argOptions.QueueName, ep =>
{
if (!argOptions.DisableQueue2LevelRetry)
{
ep.UseScheduledRedelivery(r => r.Intervals(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(5)));
}
if (!argOptions.DisableQueueRetry)
{
ep.UseMessageRetry(r => r.Immediate(2));
}
if (argOptions.QueueIsExclusive)
{
ep.ExclusiveConsumer = argOptions.QueueIsExclusive;
}
if (!argOptions.DisableQueueOutbox)
{
ep.UseInMemoryOutbox();
}
ep.Consumer <Consumers.NewDataAvailableConsumer>();
ep.Consumer <Consumers.InitialProcessingCompletedConsumer>();
ep.Consumer <Consumers.FinalProcessingCompletedConsumer>();
});
if (!argOptions.DisableNoteworthyQueue)
{
sbc.ReceiveEndpoint("noteworthy_queue", ep =>
{
ep.Consumer <Consumers.SomethingNoteworthyHappenedConsumer>();
});
}
if (!argOptions.DisableFaultQueue)
{
sbc.ReceiveEndpoint("fault_queue", ep =>
{
// can also declare handlers and consumer with a lambda
ep.Handler <Fault <NewDataAvailable> >(context =>
{
var msg = context.Message;
return(Console.Out.WriteLineAsync($"{context.MessageId} - {context.ConversationId} - Fault<NewDataAvailable>: {msg.Message.Text}"));
});
});
}
}
