public HighloadFrontController(IHttpContextAccessor httpContextAccessor, IOptions <IntegrationProperties> options, QPHelper helper, IHttpClientFactory factory)
{
_httpContext = httpContextAccessor.HttpContext;
_options = options.Value;
_qpHelper = helper;
_factory = factory;
}
public TarantoolController(
IHttpContextAccessor httpContextAccessor,
IOptions <IntegrationProperties> options,
IHttpClientFactory factory
)
{
_httpContext = httpContextAccessor.HttpContext;
_options = options.Value;
_factory = factory;
}
public static IUnityContainer Configure(
IUnityContainer container,
LoaderProperties loaderProperties,
IntegrationProperties integrationProperties,
Properties properties)
{
container = RegisterTypes(container, loaderProperties, integrationProperties, properties);
ObjectFactoryConfigurator.DefaultContainer = container;
return(container);
}
// This method gets called by the runtime. Use this method to add services to the container
public void ConfigureServices(IServiceCollection services)
{
services.AddOptions();
services.AddHttpContextAccessor();
services.AddTransient <IActionContextAccessor, ActionContextAccessor>();
services.AddTransient <QPHelper>();
services.Configure <ConnectionProperties>(Configuration.GetSection("Connection"));
services.Configure <LoaderProperties>(Configuration.GetSection("Loader"));
services.Configure <IntegrationProperties>(Configuration.GetSection("Integration"));
services.Configure <QPOptions>(Configuration.GetSection("QP"));
var props = new IntegrationProperties();
Configuration.Bind("Integration", props);
services.Configure <ForwardedHeadersOptions>(options =>
{
options.ForwardedProtoHeaderName = "X-FORWARDED-PROTO";
options.ForwardedHeaders =
ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
// Only loopback proxies are allowed by default.
// Clear that restriction because forwarders are enabled by explicit
// configuration.
options.KnownNetworks.Clear();
options.KnownProxies.Clear();
});
services.AddDistributedMemoryCache();
services.AddHttpClient();
services.Configure <CookiePolicyOptions>(options =>
{
options.Secure = CookieSecurePolicy.SameAsRequest;
options.MinimumSameSitePolicy = props.UseSameSiteNone ? SameSiteMode.None : SameSiteMode.Lax;
});
services.AddSession(options =>
{
options.Cookie.IsEssential = true;
options.Cookie.SecurePolicy = CookieSecurePolicy.SameAsRequest;
options.Cookie.SameSite = props.UseSameSiteNone ? SameSiteMode.None : SameSiteMode.Lax;
});
services.AddResponseCaching();
services
.AddMvc(options =>
{
options.EnableEndpointRouting = false;
options.ModelBinderProviders.Insert(0, new ActionContextModelBinderProvider());
})
.AddXmlSerializerFormatters().AddControllersAsServices().AddNewtonsoftJson();
}
public void ConfigureContainer(IUnityContainer container)
{
var loaderProps = new LoaderProperties();
Configuration.Bind("Loader", loaderProps);
var props = new Properties();
Configuration.Bind("Properties", props);
var integrationProps = new IntegrationProperties();
Configuration.Bind("Integration", integrationProps);
UnityConfig.Configure(container, loaderProps, integrationProps, props);
}
public QPNotificationService(
IContentProvider <NotificationChannel> channelProvider,
Func <string, IArticleFormatter> getFormatter,
IProductLocalizationService localizationService,
IIdentityProvider identityProvider,
IOptions <IntegrationProperties> integrationProps,
IHttpClientFactory httpClientFactory
)
{
_channelProvider = channelProvider;
_getFormatter = getFormatter;
_localizationService = localizationService;
_identityProvider = identityProvider;
_integrationProperties = integrationProps.Value;
_httpClientFactory = httpClientFactory;
}
private static void RegisterExtraValidation(IUnityContainer container, IntegrationProperties integrationProperties)
{
var extra = integrationProperties.ExtraValidationLibraries;
if (extra != null)
{
foreach (var library in extra)
{
var assembly = Assembly.LoadFile(Path.Combine(
AppDomain.CurrentDomain.BaseDirectory,
library + ".dll")
);
foreach (var t in assembly.GetExportedTypes())
{
if (typeof(IRemoteValidator2).IsAssignableFrom(t) && t.IsClass && !t.IsAbstract)
{
container.RegisterType(typeof(IRemoteValidator2), t, t.Name);
}
}
}
}
}
public static IUnityContainer RegisterTypes(
IUnityContainer container,
LoaderProperties loaderProperties,
IntegrationProperties integrationProperties,
Properties properties)
{
//fix Diagnostic extension
container.RegisterType <ILoggerFactory, LoggerFactory>(
new ContainerControlledLifetimeManager(), new InjectionConstructor(new ResolvedParameter <IEnumerable <ILoggerProvider> >())
);
container.AddExtension(new Diagnostic());
container.RegisterType <DynamicResourceDictionaryContainer>();
container.RegisterType <ProcessRemoteValidationIf>();
container.AddNewExtension <LoaderConfigurationExtension>();
container.AddNewExtension <ActionContainerConfiguration>();
container.AddNewExtension <TaskContainerConfiguration>();
container.AddNewExtension <ValidationConfiguration>();
container.RegisterType <IConnectionProvider, CoreConnectionProvider>();
container.RegisterType <ICustomerProvider, CustomerProvider>();
container.RegisterType <IIdentityProvider, CoreIdentityWithSessionProvider>();
// логируем в консоль
//container.RegisterInstance<ILogger>(new TextWriterLogger(Console.Out));
container.RegisterInstance <ILogger>(new NLogLogger("NLogClient.config"));
container.RegisterType <IContentDefinitionService, ContentDefinitionService>();
container.RegisterType <DefinitionEditorService>();
container
.RegisterType <IXmlProductService, XmlProductService>()
.RegisterType <IUserProvider, HttpContextUserProvider>()
.RegisterType <IQPNotificationService, QPNotificationService>()
// change default provider to filesystem-based one since it does not require app to recompile on changes.
// AppDataProductControlProvider does not cache reads from disk
.RegisterType <IProductControlProvider, ContentBasedProductControlProvider>();
container.RegisterFactory <CustomActionService>(c =>
{
var customer = c.Resolve <IConnectionProvider>().GetCustomer();
return(new CustomActionService(
new QpConnectionInfo(customer.ConnectionString, (DatabaseType)customer.DatabaseType),
1));
});
container.RegisterType <IRegionTagReplaceService, RegionTagService>();
container.RegisterType <IRegionService, RegionService>();
container.RegisterType <INotesService, NotesFromContentService>();
container.RegisterType <IProductUpdateService, ProductUpdateService>();
//container.RegisterType<IRegionTagReplaceService, RegionTagReplaceService>();
BindingValueProviderFactory.Current = new DefaultBindingValueProviderFactory(new QPModelBindingValueProvider());
container.RegisterType <ILoggerFactory, LoggerFactory>(new ContainerControlledLifetimeManager(), new InjectionConstructor(new ResolvedParameter <IEnumerable <ILoggerProvider> >()));
container.RegisterType <ITaskService, TaskService>();
container.RegisterType <IProductRelevanceService, ProductRelevanceService>();
var entitiesAssembly = typeof(IArticleFilter).Assembly;
foreach (var filterClass in entitiesAssembly.GetExportedTypes().Where(x => typeof(IArticleFilter).IsAssignableFrom(x) && x.IsClass && !x.IsAbstract))
{
container.RegisterType(typeof(IArticleFilter), filterClass, filterClass.Name);
}
container.RegisterType <IProductChangeSubscriber, RelevanceUpdaterOnProductChange>("RelevanceUpdaterOnProductChange");
container.RegisterFactory <IProductChangeNotificator>(x =>
{
var notificator = new ProductChangeNotificator(x.Resolve <ILogger>());
notificator.AddSubscribers(x.ResolveAll <IProductChangeSubscriber>());
return(notificator);
}, new ContainerControlledLifetimeManager());
container.RegisterType <IContentProvider <NotificationChannel>, NotificationChannelProvider>();
container.AddNewExtension <FormattersContainerConfiguration>();
container.RegisterType <StructureCacheTracker>();
container.RegisterType <IWarmUpProvider, ProductLoaderWarmUpProvider>();
container.RegisterSingleton <WarmUpRepeater>();
switch (loaderProperties.SettingsSource)
{
case SettingsSource.Content:
container.RegisterType <ISettingsService, SettingsFromContentCoreService>(new InjectionConstructor(typeof(VersionedCacheProviderBase), typeof(IConnectionProvider), loaderProperties.SettingsContentId));
break;
case SettingsSource.AppSettings:
container.RegisterType <ISettingsService, SettingsFromQpCoreService>();
break;
}
switch (loaderProperties.DefaultSerializer)
{
case DefaultSerializer.Json:
container.RegisterType <IArticleFormatter, JsonProductFormatter>();
break;
case DefaultSerializer.Xml:
container.RegisterType <IArticleFormatter, XmlProductFormatter>();
break;
}
var connection = container.Resolve <IConnectionProvider>();
if (connection.QPMode)
{
container
.RegisterConsolidationCache(properties.AutoRegisterConsolidationCache)
.As <IFactory>()
.With <FactoryWatcher>(properties.WatcherInterval)
.Watch();
}
else
{
container.RegisterType <ICustomerProvider, SingleCustomerCoreProvider>()
.RegisterConsolidationCache(properties.AutoRegisterConsolidationCache, SingleCustomerCoreProvider.Key)
.As <IFactory>()
.With <FactoryWatcher>()
.WithCallback((sender, e) => { container.Resolve <WarmUpRepeater>().Start(); })
.Watch();
}
if (connection.QPMode || connection.UseQPMonitoring)
{
container.RegisterQpMonitoring();
}
else
{
container.RegisterNonQpMonitoring();
}
RegisterExtraValidation(container, integrationProperties);
return(container);
}
public CustomerProvider(ILogger logger, IOptions <IntegrationProperties> integrationProps)
{
_logger = logger;
_integrationProps = integrationProps.Value;
}
public ConnectionService(IHttpContextAccessor httpContextAccessor, DataOptions options, IOptions <IntegrationProperties> intOptions)
{
_context = httpContextAccessor.HttpContext;
_options = options;
_intOptions = intOptions.Value;
}
public HealthCheckController(DataOptions options, IOptions <IntegrationProperties> integrationProps)
{
_options = options;
_intOptions = integrationProps.Value;
}
