private void ConfigureMassTransit(IServiceCollection services, ContainerBuilder containerBuilder)
{
services.AddScoped <IHostedService, MassTransitHostedService>();
//services.AddScoped<UserCheckoutAcceptedIntegrationEventHandler>();
containerBuilder.Register(c =>
{
var busControl = Bus.Factory.CreateUsingRabbitMq(sbc =>
{
var host = sbc.Host(new Uri(Configuration["EventBus:Uri"]), h =>
{
h.Username(Configuration["EventBus:Username"]);
h.Password(Configuration["EventBus:Password"]);
});
/*sbc.ReceiveEndpoint(host, "basket_checkout_queue", e =>
* {
* e.Consumer<UserCheckoutAcceptedIntegrationEventHandler>(c);
* });*/
sbc.UseExtensionsLogging(_loggerFactory);
});
var consumeObserver = new ConsumeObserver(_loggerFactory.CreateLogger <ConsumeObserver>());
busControl.ConnectConsumeObserver(consumeObserver);
var sendObserver = new SendObserver(_loggerFactory.CreateLogger <SendObserver>());
busControl.ConnectSendObserver(sendObserver);
return(busControl);
})
.As <IBusControl>()
.As <IPublishEndpoint>()
.SingleInstance();
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.Configure <PaymentSettings>(Configuration);
services.AddEntityFrameworkNpgsql().AddDbContext <PaymentContext>(options =>
{
options.UseNpgsql(Configuration["ConnectionString"],
npgsqlOptionsAction: sqlOptions =>
{
sqlOptions.MigrationsAssembly(typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
//Configuring Connection Resiliency: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-resiliency
sqlOptions.EnableRetryOnFailure(maxRetryCount: 5);
});
// Changing default behavior when client evaluation occurs to throw.
// Default in EF Core would be to log a warning when client evaluation is performed.
options.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning));
//Check Client vs. Server evaluation: https://docs.microsoft.com/en-us/ef/core/querying/client-eval
});
var containerBuilder = new ContainerBuilder();
services.AddScoped <IHostedService, MassTransitHostedService>();
services.AddScoped <OrderStatusChangedToStockConfirmedIntegrationEventHandler>();
containerBuilder.Register(c =>
{
var busControl = Bus.Factory.CreateUsingRabbitMq(sbc =>
{
var host = sbc.Host(new Uri(Configuration["EventBusConnection"]), h =>
{
h.Username(Configuration["EventBusUserName"]);
h.Password(Configuration["EventBusPassword"]);
});
sbc.ReceiveEndpoint(host, "validate_payment_queue", e =>
{
e.Consumer <OrderStatusChangedToStockConfirmedIntegrationEventHandler>(c);
});
sbc.UseExtensionsLogging(_loggerFactory);
});
var consumeObserver = new ConsumeObserver(_loggerFactory.CreateLogger <ConsumeObserver>());
busControl.ConnectConsumeObserver(consumeObserver);
var sendObserver = new SendObserver(_loggerFactory.CreateLogger <SendObserver>());
busControl.ConnectSendObserver(sendObserver);
return(busControl);
})
.As <IBusControl>()
.As <IPublishEndpoint>()
.SingleInstance();
containerBuilder.Populate(services);
return(new AutofacServiceProvider(containerBuilder.Build()));
}
private void ConfigureMassTransit(IServiceCollection services, ContainerBuilder containerBuilder)
{
services.AddScoped <IHostedService, MassTransitHostedService>();
services.AddScoped <UserCheckoutAcceptedIntegrationEventHandler>();
containerBuilder.Register(c =>
{
var busControl = Bus.Factory.CreateUsingRabbitMq(sbc =>
{
var host = sbc.Host(new Uri(Configuration["EventBusConnection"]), h =>
{
h.Username(Configuration["EventBusUserName"]);
h.Password(Configuration["EventBusPassword"]);
});
sbc.ReceiveEndpoint(host, "basket_checkout_queue", e =>
{
e.Consumer <UserCheckoutAcceptedIntegrationEventHandler>(c);
});
sbc.ReceiveEndpoint(host, "stock_confirmed_queue", e =>
{
});
sbc.ReceiveEndpoint(host, "stock_rejected_queue", e =>
{
});
sbc.ReceiveEndpoint(host, "payment_succeded_queue", e =>
{
});
sbc.ReceiveEndpoint(host, "payment_failed_queue", e =>
{
});
sbc.ReceiveEndpoint(host, "graceperiod_confirmed_queue", e =>
{
});
sbc.ReceiveEndpoint(host, "order_validation_state", e =>
{
e.UseRetry(x =>
{
x.Handle <DbUpdateConcurrencyException>();
x.Interval(5, TimeSpan.FromMilliseconds(100));
}); // Add the retry middleware for optimistic concurrency
e.StateMachineSaga(new GracePeriodStateMachine(c.Resolve <IAggregateStore>()), new InMemorySagaRepository <GracePeriod>());
});
sbc.UseExtensionsLogging(_loggerFactory);
sbc.UseInMemoryScheduler();
});
var consumeObserver = new ConsumeObserver(_loggerFactory.CreateLogger <ConsumeObserver>());
busControl.ConnectConsumeObserver(consumeObserver);
var sendObserver = new SendObserver(_loggerFactory.CreateLogger <SendObserver>());
busControl.ConnectSendObserver(sendObserver);
return(busControl);
})
.As <IBusControl>()
.As <IPublishEndpoint>()
.SingleInstance();
}
private static IBusControl CreateUsingRabbitMq()
{
var consumeObserver = new ConsumeObserver();
var bus = MassTransit.Bus.Factory.CreateUsingRabbitMq(x =>
{
x.Host(new Uri(ConfigurationManager.RabbitMqDefinitions.Host), h =>
{
h.Username(ConfigurationManager.RabbitMqDefinitions.UserName);
h.Password(ConfigurationManager.RabbitMqDefinitions.Password);
h.UseCluster(c =>
{
foreach (var node in ConfigurationManager.RabbitMqDefinitions.Servers.Split(",").ToArray())
{
c.Node(node);
}
});
});
x.UseConcurrencyLimit(1);
x.ReceiveEndpoint("ENews.Events.V1.NewsCreated", e =>
{
e.PrefetchCount = 1;
e.UseRetry(retryConfig =>
{
retryConfig.Incremental(3, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(5));
});
e.Consumer <NewsCreatedConsumer>();
});
x.ConnectConsumeObserver(consumeObserver);
});
return(bus);
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc(options =>
{
options.Filters.Add(typeof(HttpGlobalExceptionFilter));
options.Filters.Add(typeof(ValidateModelStateFilter));
}).AddControllersAsServices();
ConfigureAuthService(services);
services.Configure <BasketSettings>(Configuration);
//By connecting here we are making sure that our service
//cannot start until redis is ready. This might slow down startup,
//but given that there is a delay on resolving the ip address
//and then creating the connection it seems reasonable to move
//that cost to startup instead of having the first request pay the
//penalty.
services.AddSingleton <ConnectionMultiplexer>(sp =>
{
var settings = sp.GetRequiredService <IOptions <BasketSettings> >().Value;
var configuration = ConfigurationOptions.Parse(settings.ConnectionString, true);
configuration.ResolveDns = true;
return(ConnectionMultiplexer.Connect(configuration));
});
services.AddCors(options =>
{
options.AddPolicy("CorsPolicy",
policyBuilder => policyBuilder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()
.AllowCredentials());
});
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddTransient <IBasketRepository, RedisBasketRepository>();
services.AddTransient <IIdentityService, IdentityService>();
services.AddOptions();
// Configurar MassTransit
services.AddScoped <IHostedService, MassTransitHostedService>();
services.AddScoped <ProductPriceChangedIntegrationEventHandler>();
services.AddScoped <OrderStartedIntegrationEventHandler>();
var builder = new ContainerBuilder();
builder.Register(c =>
{
var busControl = Bus.Factory.CreateUsingRabbitMq(sbc =>
{
var host = sbc.Host(new Uri(Configuration["EventBusConnection"]), h =>
{
h.Username(Configuration["EventBusUserName"]);
h.Password(Configuration["EventBusPassword"]);
});
sbc.ReceiveEndpoint(host, "price_updated_queue", e =>
{
e.Consumer <ProductPriceChangedIntegrationEventHandler>(c);
});
sbc.ReceiveEndpoint(host, "order_started_queue", e =>
{
e.Consumer <OrderStartedIntegrationEventHandler>(c);
});
sbc.UseExtensionsLogging(_loggerFactory);
});
var consumeObserver = new ConsumeObserver(_loggerFactory.CreateLogger <ConsumeObserver>());
busControl.ConnectConsumeObserver(consumeObserver);
var sendObserver = new SendObserver(_loggerFactory.CreateLogger <SendObserver>());
busControl.ConnectSendObserver(sendObserver);
return(busControl);
})
.As <IBusControl>()
.As <IPublishEndpoint>()
.SingleInstance();
services.AddTransient <IValidator <CustomerBasket>, CustomerBasketValidator>();
builder.Populate(services);
var container = builder.Build();
// Create the IServiceProvider based on the container.
return(new AutofacServiceProvider(container));
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddScoped <IHostedService, MassTransitHostedService>();
services.AddScoped <OrderStatusChangedToAwaitingValidationIntegrationEventHandler>();
services.AddScoped <OrderStatusChangedToCancelledIntegrationEventHandler>();
services.AddScoped <OrderStatusChangedToPaidIntegrationEventHandler>();
services.AddScoped <OrderStatusChangedToShippedIntegrationEventHandler>();
services.AddScoped <OrderStatusChangedToStockConfirmedIntegrationEventHandler>();
services.AddScoped <OrderStatusChangedToSubmittedIntegrationEventHandler>();
services.AddScoped <AccountDepositIntegrationEventHandler>();
services.AddCors(options =>
{
options.AddPolicy("CorsPolicy",
builder => builder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()
.AllowCredentials());
});
if (Configuration.GetValue <string>("IsClusterEnv") == bool.TrueString)
{
services
.AddSignalR()
.AddRedis(Configuration["SignalrStoreConnectionString"]);
}
else
{
services.AddSignalR();
}
ConfigureAuthService(services);
services.AddOptions();
//configure autofac
var container = new ContainerBuilder();
container.Register(c =>
{
var busControl = Bus.Factory.CreateUsingRabbitMq(sbc =>
{
var host = sbc.Host(new Uri(Configuration["EventBusConnection"]), h =>
{
h.Username(Configuration["EventBusUserName"]);
h.Password(Configuration["EventBusPassword"]);
});
sbc.ReceiveEndpoint(host, "order_awaitingvalidation_signalr_queue", e =>
{
e.Consumer <OrderStatusChangedToAwaitingValidationIntegrationEventHandler>(c);
});
sbc.ReceiveEndpoint(host, "order_cancelled_signalr_queue", e =>
{
e.Consumer <OrderStatusChangedToCancelledIntegrationEventHandler>(c);
});
sbc.ReceiveEndpoint(host, "order_paid_signalr_queue", e =>
{
e.Consumer <OrderStatusChangedToPaidIntegrationEventHandler>(c);
});
sbc.ReceiveEndpoint(host, "order_shipped_signalr_queue", e =>
{
e.Consumer <OrderStatusChangedToShippedIntegrationEventHandler>(c);
});
sbc.ReceiveEndpoint(host, "order_stockconfirmed_signalr_queue", e =>
{
e.Consumer <OrderStatusChangedToStockConfirmedIntegrationEventHandler>(c);
});
sbc.ReceiveEndpoint(host, "order_submitted_signalr_queue", e =>
{
e.Consumer <OrderStatusChangedToSubmittedIntegrationEventHandler>(c);
});
sbc.ReceiveEndpoint(host, "payment_amount_deposit", e =>
{
e.Consumer <AccountDepositIntegrationEventHandler>(c);
});
sbc.UseExtensionsLogging(_loggerFactory);
});
var consumeObserver = new ConsumeObserver(_loggerFactory.CreateLogger <ConsumeObserver>());
busControl.ConnectConsumeObserver(consumeObserver);
var sendObserver = new SendObserver(_loggerFactory.CreateLogger <SendObserver>());
busControl.ConnectSendObserver(sendObserver);
return(busControl);
})
.As <IBusControl>()
.As <IPublishEndpoint>()
.SingleInstance();
container.Populate(services);
return(new AutofacServiceProvider(container.Build()));
}
