protected DatabaseAccess() : this(/*initialize*/ false) { } // Used By PlatformDatabaseAcesss
/// <summary>
/// Create a new instance of the <see cref="DatabaseAccess"/> class using the given <c>IDatabaseServices</c>.
/// </summary>
/// <param name="initialize">True to initialize the providers, false otherwise</param>
private DatabaseAccess(bool initialize)
{
if (initialize)
{
var source = AccessRequester;
systemProvider = CreatePlatformDatabaseAccessProvider(source, DatabaseSettingsSerialization.User.Runtime);
sessionProvider = CreatePlatformDatabaseAccessProvider(source, DatabaseSettingsSerialization.User.Session);
loggingProvider = CreatePlatformDatabaseAccessProvider(source, DatabaseSettingsSerialization.User.Log);
}
}
/// <summary>
/// Create a new instance of the <see cref="DatabaseAccess"/> class using the given <c>IDatabaseServices</c>.
/// </summary>
/// <param name="initialize">True to initialize the providers, false otherwise</param>
/// <param name="settingsProvider">True to initialize the providers, false otherwise</param>
private DatabaseAccess(bool initialize, ISettingsProvider settingsProvider)
{
if (initialize)
{
this.settingsProvider = settingsProvider;
var source = settingsProvider.Get <bool>(RuntimePlatformSettings.Application.IsApplication) ? DatabaseSettingsSerialization.Source.Application : DatabaseSettingsSerialization.Source.Services;
systemProvider = CreatePlatformDatabaseAccessProvider(source, DatabaseSettingsSerialization.User.Runtime, DatabaseSettingsSerialization.DataSpace.Platform, settingsProvider);
#if SPLIT_DEVELOPMENT
runtimeProvider = CreatePlatformDatabaseAccessProvider(source, DatabaseSettingsSerialization.User.Runtime, DatabaseSettingsSerialization.DataSpace.Business, settingsProvider);
#endif
}
}
/// <summary>
/// The DatabaseAccessProvider responsible for connecting to a specific external database connection
/// </summary>
/// <param name="connectionName">Name of the connection.</param>
/// <returns>An object to access the database</returns>
protected internal virtual DatabaseAccessProvider <IDatabaseServices> GetDBConnectionProvider(string connectionName)
{
connectionName = connectionName.ToUpperInvariant();
DatabaseAccessProvider <IDatabaseServices> provider;
if (!dbConnectionProviders.TryGetValue(connectionName, out provider))
{
lock (dbConnectionProviders) {
if (!dbConnectionProviders.TryGetValue(connectionName, out provider))
{
ITransactionManager transactionManager = GetTransactionManager(connectionName);
provider = new DatabaseAccessProvider <IDatabaseServices>(transactionManager.TransactionService.DatabaseServices, transactionManager);
dbConnectionProviders.Add(connectionName, provider);
}
}
}
return(provider);
}
protected static DatabaseAccessProvider <IPlatformDatabaseServices> GetProviderForDatabase(IRuntimeDatabaseConfiguration configurationForDatabase,
DatabaseSettingsSerialization.User user, DatabaseAccessProvider <IPlatformDatabaseServices> systemDatabaseProvider,
IDictionary <string, DatabaseAccessProvider <IPlatformDatabaseServices> > providersByIdentifier,
IDictionary <string, ITransactionManager> transactionManagersByIdentifier)
{
if (configurationForDatabase == null)
{
return(systemDatabaseProvider);
}
bool supportsUnifiedTransactionManager = (user == DatabaseSettingsSerialization.User.Admin) ||
Settings.GetBool(Settings.Configs.SupportUnifiedMDC);
var systemConfig = systemDatabaseProvider.DatabaseServices.DatabaseConfiguration;
string managerIdentifier = supportsUnifiedTransactionManager ?
configurationForDatabase.Username
: configurationForDatabase.DatabaseIdentifier;
string systemManagerIdentifier = supportsUnifiedTransactionManager ?
systemConfig.Username
: systemConfig.DatabaseIdentifier;
bool sameIdentifier = managerIdentifier.EqualsIgnoreCase(systemManagerIdentifier);
// If using the system manager to access the system database, we can use the SystemProvider
bool sameDatabase = configurationForDatabase.DatabaseIdentifier.EqualsIgnoreCase(systemConfig.DatabaseIdentifier);
if (sameIdentifier && sameDatabase)
{
return(systemDatabaseProvider);
}
// In unified MDC scenarios, we want to use a provider with a shared transaction manager
// while keeping the original configuration that uses the correct database identifier
string providerIdentifier = managerIdentifier + (supportsUnifiedTransactionManager ? "-" + configurationForDatabase.DatabaseIdentifier : "");
DatabaseAccessProvider <IPlatformDatabaseServices> provider;
if (!providersByIdentifier.TryGetValue(providerIdentifier, out provider))
{
lock (providersByIdentifier) {
if (!providersByIdentifier.TryGetValue(providerIdentifier, out provider))
{
ITransactionManager manager = sameIdentifier ? systemDatabaseProvider.TransactionManager : null;
if (manager == null && !transactionManagersByIdentifier.TryGetValue(managerIdentifier, out manager))
{
var services = PlatformDatabasePluginProvider
.GetImplementation(configurationForDatabase.ProviderKey())
.GetPlatformDatabaseServices(configurationForDatabase);
manager = services.TransactionService.CreateTransactionManager();
transactionManagersByIdentifier.Add(managerIdentifier, manager);
}
// TODO: Check with the Stack Team if we can optimized this
var dapServices = PlatformDatabasePluginProvider
.GetImplementation(configurationForDatabase.ProviderKey())
.GetPlatformDatabaseServices(configurationForDatabase);
dapServices.IntrospectionService.QueryTimeout = IntrospectionQueryTimeout;
provider = new DatabaseAccessProvider <IPlatformDatabaseServices>(
dapServices,
manager);
providersByIdentifier.Add(providerIdentifier, provider);
}
}
}
return(provider);
}
protected static DatabaseAccessProvider <IPlatformDatabaseServices> GetProviderForDatabase(IRuntimeDatabaseConfiguration configurationForDatabase,
DatabaseSettingsSerialization.User user, DatabaseAccessProvider <IPlatformDatabaseServices> baseProvider,
IDictionary <string, DatabaseAccessProvider <IPlatformDatabaseServices> > providersByIdentifier,
IDictionary <string, ITransactionManager> transactionManagersByIdentifier)
{
if (configurationForDatabase == null)
{
return(baseProvider);
}
// ***************** MDC STUFF ***************************
var databaseConfig = baseProvider.DatabaseServices.DatabaseConfiguration;
string managerIdentifier = configurationForDatabase.Username;
string databaseManagerIdentifier = databaseConfig.Username;
bool sameIdentifier = managerIdentifier.EqualsIgnoreCase(databaseManagerIdentifier);
// If using the system manager to access the system database, we can use the SystemProvider
bool sameDatabase = configurationForDatabase.DatabaseIdentifier.EqualsIgnoreCase(databaseConfig.DatabaseIdentifier);
if (sameIdentifier && sameDatabase)
{
return(baseProvider);
}
// In unified MDC scenarios, we want to use a provider with a shared transaction manager
// while keeping the original configuration that uses the correct database identifier
string providerIdentifier = managerIdentifier + "-" + configurationForDatabase.DatabaseIdentifier;
DatabaseAccessProvider <IPlatformDatabaseServices> provider;
if (!providersByIdentifier.TryGetValue(providerIdentifier, out provider))
{
lock (providersByIdentifier) {
if (!providersByIdentifier.TryGetValue(providerIdentifier, out provider))
{
ITransactionManager manager = sameIdentifier ? baseProvider.TransactionManager : null;
if (manager == null && !transactionManagersByIdentifier.TryGetValue(managerIdentifier, out manager))
{
var services = PlatformDatabasePluginProvider
.GetImplementation(configurationForDatabase.DatabaseProvider.Key)
.GetPlatformDatabaseServices(configurationForDatabase);
manager = services.TransactionService.CreateTransactionManager();
transactionManagersByIdentifier.Add(managerIdentifier, manager);
}
// TODO: Check with the Stack Team if we can optimized this
var dapServices = PlatformDatabasePluginProvider
.GetImplementation(configurationForDatabase.DatabaseProvider.Key)
.GetPlatformDatabaseServices(configurationForDatabase);
provider = new DatabaseAccessProvider <IPlatformDatabaseServices>(
dapServices,
manager);
providersByIdentifier.Add(providerIdentifier, provider);
}
}
}
// ***************** MDC STUFF ***************************
return(provider);
}
