public static async Task <UpdateableServiceProvider> StartNServiceBus(this UpdateableServiceProvider serviceProvider, IConfiguration configuration)
{
var connectionFactory = serviceProvider.GetService <IConnectionFactory>();
var endpointConfiguration = new EndpointConfiguration("SFA.DAS.ApprenticeCommitments.Api")
.UseMessageConventions()
.UseNewtonsoftJsonSerializer()
.UseOutbox(true)
.UseServicesBuilder(serviceProvider)
.UseSqlServerPersistence(() => connectionFactory.CreateConnection(configuration["ApplicationSettings:DbConnectionString"]))
.UseUnitOfWork();
if (UseLearningTransport(configuration))
{
endpointConfiguration.UseTransport <LearningTransport>();
}
else
{
endpointConfiguration.UseAzureServiceBusTransport(configuration["ApplicationSettings:NServiceBusConnectionString"]);
}
if (!string.IsNullOrEmpty(configuration["ApplicationSettings:NServiceBusLicense"]))
{
endpointConfiguration.License(configuration["ApplicationSettings:NServiceBusLicense"]);
}
var endpoint = await Endpoint.Start(endpointConfiguration);
serviceProvider.AddSingleton(p => endpoint)
.AddSingleton <IMessageSession>(p => p.GetService <IEndpointInstance>())
.AddHostedService <NServiceBusHostedService>();
return(serviceProvider);
}
public void ConfigureContainer(UpdateableServiceProvider serviceProvider)
{
if (!Configuration["Environment"].Equals("DEV", StringComparison.CurrentCultureIgnoreCase))
{
serviceProvider.StartNServiceBus(Configuration, ConfigurationIsLocalOrDev());
}
}
public static void StartNServiceBus(this UpdateableServiceProvider serviceProvider,
IConfiguration configuration, bool configurationIsLocalOrDev)
{
var endpointConfiguration = new EndpointConfiguration("SFA.DAS.Reservations.Api")
.UseInstallers()
.UseMessageConventions()
.UseNewtonsoftJsonSerializer()
.UseOutbox(true)
.UseServicesBuilder(serviceProvider)
.UseSqlServerPersistence(() => new SqlConnection(configuration["Reservations:ConnectionString"]))
.UseUnitOfWork();
if (configurationIsLocalOrDev)
{
endpointConfiguration.UseLearningTransport();
}
else
{
endpointConfiguration.UseAzureServiceBusTransport(
configuration["Reservations:NServiceBusConnectionString"], r => { });
}
if (!string.IsNullOrEmpty(configuration["Reservations:NServiceBusLicense"]))
{
endpointConfiguration.License(configuration["Reservations:NServiceBusLicense"]);
}
var endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
serviceProvider.AddSingleton(p => endpoint)
.AddSingleton <IMessageSession>(p => p.GetService <IEndpointInstance>())
.AddHostedService <NServiceBusHostedService>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddCors(c =>
{
c.AddPolicy("AllowOrigin", options => options.AllowAnyOrigin());
});
services.AddSingleton <IMessageRepository, MessageRepository>();
services.AddTransient <EmailService>();
services.AddTransient <SMSService>();
services.AddTransient <Func <NotificationType, INotificationService> >(serviceProvider => key =>
{
switch (key)
{
case NotificationType.Email:
return(serviceProvider.GetService <EmailService>());
case NotificationType.SMS:
return(serviceProvider.GetService <SMSService>());
default:
throw new KeyNotFoundException();
}
});
// services.AddSingleton<IPaymentRepository, PaymentRepository>();
services.AddSingleton(sp => endpoint);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
// Configure NServiceBus
var endpointConfiguration = new EndpointConfiguration("Assignment.Notifications");
var transport = endpointConfiguration.UseTransport <LearningTransport>();
endpointConfiguration.SendFailedMessagesTo("failed");
endpointConfiguration.AuditProcessedMessagesTo("audit");
endpointConfiguration.SendHeartbeatTo("Particular.ServiceControl");
var metrics = endpointConfiguration.EnableMetrics();
metrics.SendMetricDataToServiceControl("Particular.Monitoring", TimeSpan.FromMilliseconds(500));
UpdateableServiceProvider container = null;
endpointConfiguration.UseContainer <ServicesBuilder>(customizations =>
{
customizations.ExistingServices(services);
customizations.ServiceProviderFactory(sc =>
{
container = new UpdateableServiceProvider(sc);
return(container);
});
});
endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
return(container);
}
public static void MicroServicesModuleRegister(this IServiceCollection services, IConfiguration configuration)
{
IEndpointInstance endpointInstance = null;
services.AddSingleton <IMessageSession>(_ => endpointInstance);
var endpointConfiguration = new EndpointConfiguration(configuration.GetSection("MicroServices").GetSection("Endpoint").Value);
var transport = endpointConfiguration.UseTransport <RabbitMQTransport>();
transport.ConnectionString(configuration.GetSection("Transport")["RabbitMQConnectionString"]);
transport.UsePublisherConfirms(true);
transport.UseDirectRoutingTopology();
endpointConfiguration.EnableInstallers();
endpointConfiguration.EnableCallbacks();
var routerConfig = transport.Routing();
routerConfig.RouteToEndpoint(
assembly: typeof(MqttReceivedMessage).Assembly,
destination: configuration.GetSection("MicroServices").GetSection("Endpoint").Value);
routerConfig.RouteToEndpoint(
assembly: typeof(MqttResponseMessage).Assembly,
destination: configuration.GetSection("MicroServices").GetSection("Endpoint").Value);
routerConfig.RouteToEndpoint(
assembly: typeof(MqttConnectMessage).Assembly,
destination: configuration.GetSection("MicroServices").GetSection("Endpoint").Value);
routerConfig.RouteToEndpoint(
assembly: typeof(MqttDisconnectMessage).Assembly,
destination: configuration.GetSection("MicroServices").GetSection("Endpoint").Value);
var discriminator = configuration.GetSection("MicroServices").GetSection("Discriminator").Value;
endpointConfiguration.MakeInstanceUniquelyAddressable(discriminator);
UpdateableServiceProvider container = null;
endpointConfiguration.UseContainer <ServicesBuilder>(
customizations: customizations =>
{
customizations.ExistingServices(services);
customizations.ServiceProviderFactory(service =>
{
container = new UpdateableServiceProvider(service);
return(container);
});
});
endpointInstance = Task.Run(async() => await Endpoint.Start(endpointConfiguration)).Result;
services.AddSingleton(typeof(IEndpointInstance), x => endpointInstance);
}
public static async Task <UpdateableServiceProvider> StartNServiceBus(
this UpdateableServiceProvider serviceProvider,
IConfiguration configuration)
{
var endpointName = configuration["ApplicationSettings:NServiceBusEndpointName"];
if (string.IsNullOrEmpty(endpointName))
{
endpointName = "SFA.DAS.EmployerIncentives.Functions.DomainMessageHandlers";
}
var endpointConfiguration = new EndpointConfiguration(endpointName)
.UseMessageConventions()
.UseNewtonsoftJsonSerializer()
.UseOutbox(true)
.UseServicesBuilder(serviceProvider)
.UseSqlServerPersistence(() => new SqlConnection(configuration["ApplicationSettings:DbConnectionString"]))
.UseUnitOfWork();
if (configuration["ApplicationSettings:NServiceBusConnectionString"].Equals("UseLearningEndpoint=true", StringComparison.CurrentCultureIgnoreCase))
{
endpointConfiguration
.UseTransport <LearningTransport>()
.StorageDirectory(configuration.GetValue("ApplicationSettings:UseLearningEndpointStorageDirectory",
Path.Combine(
Directory.GetCurrentDirectory().Substring(0, Directory.GetCurrentDirectory().IndexOf("src")),
@"src\SFA.DAS.EmployerIncentives.Functions.TestConsole\.learningtransport")));
endpointConfiguration.UseLearningTransport(s => s.AddRouting());
}
else
{
endpointConfiguration
.UseAzureServiceBusTransport(configuration["ApplicationSettings:NServiceBusConnectionString"], r => r.AddRouting());
}
if (!string.IsNullOrEmpty(configuration["ApplicationSettings:NServiceBusLicense"]))
{
endpointConfiguration.License(configuration["ApplicationSettings:NServiceBusLicense"]);
}
var endpoint = await Endpoint.Start(endpointConfiguration);
serviceProvider.AddSingleton(p => endpoint)
.AddSingleton <IMessageSession>(p => p.GetService <IEndpointInstance>())
.AddHostedService <NServiceBusHostedService>();
return(serviceProvider);
}
// 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_2);
services.AddLogging(loggingBuilder =>
{
loggingBuilder.AddConsole();
});
services.AddScoped <ReusedComponent>();
services.AddTransport();
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.RequireHttpsMetadata = false;
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidIssuer = Configuration["ISSUER"],
ValidateAudience = true,
ValidAudience = Configuration["AUDIENCE"],
ValidateLifetime = true,
IssuerSigningKey = AuthOptions.GetSymmetricSecurityKey(Configuration["SECRET_KEY"]),
ValidateIssuerSigningKey = true,
};
});
var endpointConfiguration = services.AddNServiceBus(Configuration);
#region Create IoC container
UpdateableServiceProvider container = null;
endpointConfiguration.UseContainer <ServicesBuilder>(customizations =>
{
customizations.ExistingServices(services);
customizations.ServiceProviderFactory(sc =>
{
container = new UpdateableServiceProvider(sc);
return(container);
});
});
#endregion
NServiceBus.Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
return(container);
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services
.AddMvcCore()
.AddCors()
.AddJsonFormatters()
.AddApiExplorer()
.SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services
.AddSignalR();
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/dist";
});
services.AddSingleton <IEquipmentRepository, EquipmentRepository>();
services.AddScoped <EquipmentFilter>();
services.AddSingleton(serviceProvider => _endpoint);
var endpointConfiguration = new EndpointConfiguration("Bondora.ConstructionEquipmentRental.Service");
// It's used for development, for real case we should use any real transport (RabbitMQ and so on).
TransportExtensions <LearningTransport> transport = endpointConfiguration.UseTransport <LearningTransport>();
UpdateableServiceProvider container = null;
endpointConfiguration.UseContainer <ServicesBuilder>(customizations =>
{
customizations.ExistingServices(services);
customizations.ServiceProviderFactory(serviceCollection =>
{
container = new UpdateableServiceProvider(serviceCollection);
return(container);
});
});
RoutingSettings <LearningTransport> routing = transport.Routing();
routing.RouteToEndpoint(
assembly: typeof(GetInvoiceCommand).Assembly,
destination: "Bondora.ConstructionEquipmentRental.Billing");
_endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
return(container);
}
public static void StartNServiceBus(this UpdateableServiceProvider serviceProvider, IConfiguration configuration)
{
var endpointName = "SFA.DAS.UnitOfWork.Sample.Web";
var endpointConfiguration = new EndpointConfiguration(endpointName)
.UseLearningTransport()
.UseErrorQueue($"{endpointName}-errors")
.UseInstallers()
.UseMessageConventions()
.UseNewtonsoftJsonSerializer()
.UseOutbox()
.UseServicesBuilder(serviceProvider)
.UseSqlServerPersistence(() => new SqlConnection(configuration.GetConnectionString("SampleDb")));
var endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
serviceProvider.AddSingleton(p => endpoint)
.AddSingleton <IMessageSession>(p => p.GetService <IEndpointInstance>())
.AddHostedService <NServiceBusHostedService>();
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
// register any services to IServiceCollection
UpdateableServiceProvider container = null;
endpointConfiguration.UseContainer <ServicesBuilder>(customizations =>
{
customizations.ExistingServices(services);
customizations.ServiceProviderFactory(sc =>
{
container = new UpdateableServiceProvider(sc);
return(container);
});
});
endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
return(container);
}
public static async Task <UpdateableServiceProvider> StartNServiceBus(
this UpdateableServiceProvider serviceProvider,
IConfiguration configuration,
string endpointName)
{
var config = configuration
.GetSection("NServiceBusConfiguration")
.Get <NServiceBusConfiguration>();
var endpointConfiguration = new EndpointConfiguration(endpointName)
.UseErrorQueue($"{endpointName}-errors")
.UseInstallers()
.UseMessageConventions()
.UseNewtonsoftJsonSerializer()
.UseNLogFactory();
if (!string.IsNullOrEmpty(config.NServiceBusLicense))
{
endpointConfiguration.UseLicense(config.NServiceBusLicense);
}
endpointConfiguration.SendOnly();
if (config.NServiceBusConnectionString.Equals("UseLearningEndpoint=true", StringComparison.CurrentCultureIgnoreCase))
{
endpointConfiguration.UseLearningTransport(s => s.AddRouting());
}
else
{
endpointConfiguration.UseAzureServiceBusTransport(config.NServiceBusConnectionString, s => s.AddRouting());
}
var endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
serviceProvider.AddSingleton(p => endpoint)
.AddSingleton <IMessageSession>(p => p.GetService <IEndpointInstance>())
.AddHostedService <NServiceBusHostedService>();
return(serviceProvider);
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddCors(c =>
{
c.AddPolicy("AllowOrigin", options => options.AllowAnyOrigin());
});
services.AddSingleton <IOrderRepository, OrderRepository>();
services.AddSingleton(sp => endpoint);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
// Configure NServiceBus
var endpointConfiguration = new EndpointConfiguration("Assignment.Orders");
var transport = endpointConfiguration.UseTransport <LearningTransport>();
endpointConfiguration.SendFailedMessagesTo("failed");
endpointConfiguration.AuditProcessedMessagesTo("audit");
endpointConfiguration.SendHeartbeatTo("Particular.ServiceControl");
var metrics = endpointConfiguration.EnableMetrics();
metrics.SendMetricDataToServiceControl("Particular.Monitoring", TimeSpan.FromMilliseconds(500));
UpdateableServiceProvider container = null;
endpointConfiguration.UseContainer <ServicesBuilder>(customizations =>
{
customizations.ExistingServices(services);
customizations.ServiceProviderFactory(sc =>
{
container = new UpdateableServiceProvider(sc);
return(container);
});
});
endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
return(container);
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddLogging(loggingBuilder => loggingBuilder.AddDebug());
services.AddSingleton <BookingFakeRepository>();
services.AddSingleton <BookedApartamentsFakeRepository>();
services.AddScoped <ReusedComponent>();
services.AddScoped <BookingService>();
services.AddTransport();
var endpointConfiguration = services.AddNServiceBus(Configuration);
#region Create IoC container
UpdateableServiceProvider container = null;
endpointConfiguration.UseContainer <ServicesBuilder>(customizations =>
{
customizations.ExistingServices(services);
customizations.ServiceProviderFactory(sc =>
{
container = new UpdateableServiceProvider(sc);
return(container);
});
});
#endregion
NServiceBus.Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
return(container);
}
// 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_2);
services.AddLogging(loggingBuilder =>
{
loggingBuilder.AddConsole();
});
services.AddScoped <ReusedComponent>();
services.AddTransport();
services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>();
RegisterComponent <DataModule>(services, Configuration);
RegisterComponent <DomainServicesModule>(services, Configuration);
RegisterComponent <InfrastructureServicesModule>(services, Configuration);
RegisterComponent <ModelMapperModule>(services, Configuration);
JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, options =>
{
options.RequireHttpsMetadata = false;
options.SaveToken = true;
options.IncludeErrorDetails = true;
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidIssuer = Configuration["ISSUER"],
ValidateAudience = true,
ValidAudience = Configuration["AUDIENCE"],
ValidateIssuerSigningKey = true,
IssuerSigningKey = AuthOptions.GetSymmetricSecurityKey(Configuration["SECRET_KEY"]),
ValidateLifetime = true,
ClockSkew = TimeSpan.FromSeconds(20)
};
});
IEndpointInstance endpointInstance = null;
services.AddSingleton <IEndpointInstance>(_ => endpointInstance);
var endpointConfiguration = services.AddNServiceBus(Configuration);
#region Create IoC container
UpdateableServiceProvider container = null;
endpointConfiguration.UseContainer <ServicesBuilder>(customizations =>
{
customizations.ExistingServices(services);
customizations.ServiceProviderFactory(sc =>
{
container = new UpdateableServiceProvider(sc);
return(container);
});
});
#endregion
endpointInstance = NServiceBus.Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
return(container);
}
public void ConfigureContainer(UpdateableServiceProvider serviceProvider)
{
serviceProvider.StartNServiceBus(Configuration).GetAwaiter().GetResult();
}
public void ConfigureContainer(UpdateableServiceProvider serviceProvider)
{
serviceProvider.StartNServiceBus(Configuration, Environment.IsDevelopment());
}
public static UpdateableServiceProvider AddNServiceBus(this IServiceCollection services, string endpointName)
{
UpdateableServiceProvider container = null;
EndpointConfiguration configuration = new EndpointConfiguration(endpointName);
configuration.UseSerialization <NewtonsoftSerializer>();
configuration.EnableInstallers();
configuration.DisableFeature <Heartbeats>();
var transport = configuration.UseTransport <RabbitMQTransport>();
configuration.UseTransport <RabbitMQTransport>();
transport.UseDirectRoutingTopology();
transport.ConnectionString("host=rabbitmq");
var routing = transport.Routing();
routing.RouteToEndpoint(typeof(Message).Assembly, "IoT.DeviceListener");
services.AddSingleton(configuration);
var sessionConfiguration = new SessionAndConfigurationHolder(configuration);
services.AddSingleton(sessionConfiguration);
configuration.UseContainer <ServicesBuilder>(customizations =>
{
customizations.ExistingServices(services);
customizations.ServiceProviderFactory(sc =>
{
container = new UpdateableServiceProvider(sc);
return(container);
});
});
//container.AddHostedService<NServiceBusHost>();
var endpointInstanse = Endpoint.Start(configuration).GetAwaiter().GetResult();
sessionConfiguration.MessageSession = endpointInstanse;
container.AddSingleton(provider =>
{
var management = provider.GetService <SessionAndConfigurationHolder>();
if (management.MessageSession != null)
{
return(management.MessageSession);
}
var timeout = TimeSpan.FromSeconds(30);
if (!SpinWait.SpinUntil(() => management.MessageSession != null || management.StartupException != null,
timeout))
{
throw new TimeoutException($"Unable to resolve the message session within '{timeout.ToString()}'. If you are trying to resolve the session within hosted services it is encouraged to use `Lazy<IMessageSession>` instead of `IMessageSession` directly");
}
management.StartupException?.Throw();
return(management.MessageSession);
});
container.AddSingleton(provider => new Lazy <IMessageSession>(provider.GetService <IMessageSession>));
return(container);
}
public void ConfigureContainer(UpdateableServiceProvider serviceProvider)
{
serviceProvider.StartNServiceBus(_configuration);
}
public static EndpointConfiguration UseServicesBuilder(this EndpointConfiguration config, UpdateableServiceProvider serviceProvider)
{
config.UseContainer <ServicesBuilder>(c => c.ServiceProviderFactory(s => serviceProvider));
return(config);
}
