//public IQueryCache QueryCache { get; }
public DatabaseService(IConnectionStringManager connectionStringManager)
{
//QueryCache = queryCache;
Connection = new SqlConnection(connectionStringManager.AppDatabase);
Connection.Open();
}
public TestDatabase(IConnectionStringManager connectionStringManager,
IDatabaseNameGenerator databaseNameGenerator, IConnection connection)
{
_connectionStringManager = connectionStringManager;
_databaseNameGenerator = databaseNameGenerator;
_connection = connection;
}
public DatabaseBuilder ForVendor(IConnectionStringManager connectionStringManager, IDatabase database, ISession session)
{
_connectionStringManager = connectionStringManager;
_database = database;
_session = session;
return(this);
}
/// <summary>
/// 构造函数
/// </summary>
public BaseDAO(T pUserInfo, IConnectionStringManager pConnectionStringManager)
{
this.CurrentUserInfo = pUserInfo;
//创建SQL Helper
string connectionString = pConnectionStringManager.GetConnectionStringBy(pUserInfo);
var sqlHelper = new DefaultSQLHelper(connectionString);
sqlHelper.CurrentUserInfo = pUserInfo;
this.SQLHelper = sqlHelper;
}
public void ConfigureAndBuild(IConnectionStringManager connectionStringManager,
IDictionary <string, object> properties, ISession session)
{
_connectionStringManager = connectionStringManager;
_session = session;
var createStatement = $"CREATE DATABASE {_connectionStringManager.TransientDatabaseName};";
_session.Execute(_connectionStringManager.DefaultConnectionString, createStatement);
}
public static Task <string> GetDefaultConnectionStringAsync(
this IConnectionStringManager connectionStringManager,
CancellationToken cancellationToken)
{
// Validate parameters.
if (connectionStringManager == null)
{
throw new ArgumentNullException(nameof(connectionStringManager));
}
// Get the default connection string.
return(connectionStringManager.GetConnectionStringAsync(DefaultConnectionStringName, cancellationToken));
}
public SQLiteDatabaseService(IKeywordService keywordService,
ILogService log,
IKeywordService reservedKeywordService,
IPluginManager pluginManager,
IConnectionStringManager csm
)
{
_pluginManager = pluginManager;
_reservedKeywordService = reservedKeywordService;
_log = log;
_connectionString = csm.Get();
_keywordService = keywordService;
}
public void ConfigureAndBuild(IConnectionStringManager connectionStringManager, IDictionary <string, object> properties,
ISession session)
{
_connectionStringManager = connectionStringManager;
if (properties != null && properties.ContainsKey("TemplateDatabase"))
{
TemplateDatabase = (string)properties["TemplateDatabase"];
}
_session = session;
_session.Execute(_connectionStringManager.DefaultConnectionString, BuildCreateStatement());
}
public void should_call_correct_create_statement()
{
var defaultConnection = $"Server=localhost;Database={RandomData.RandomWord()}";
var transientDatabase = RandomData.RandomWord();
_connectionStringManager = new ConnectionStringManager();
_connectionStringManager.ConfigureTransientConnectionString(defaultConnection, transientDatabase);
var database = new Database();
database.ConfigureAndBuild(_connectionStringManager, new Dictionary <string, object>(), _session);
_session.Received(1).Execute(Arg.Is(defaultConnection),
Arg.Is($"create database {transientDatabase};"));
}
public void should_call_correct_exists_statements()
{
var defaultConnection = $"Server=localhost;Database={RandomData.RandomWord()}";
var transientDatabase = RandomData.RandomWord();
_connectionStringManager = new ConnectionStringManager();
_connectionStringManager.ConfigureTransientConnectionString(defaultConnection, transientDatabase);
var database = new Database();
database.ConfigureAndBuild(_connectionStringManager, new Dictionary <string, object>(), _session);
database.Exists();
_session.Received(1).ExecuteReader(Arg.Is(_connectionStringManager.DefaultConnectionString),
Arg.Is($"SHOW DATABASES LIKE '{_connectionStringManager.TransientDatabaseName}';"), out int x);
}
public void should_call_scripts()
{
var defaultConnection = $"Data Source={RandomData.RandomWord()}";
var transientDatabase = RandomData.RandomWord();
_connectionStringManager = new ConnectionStringManager();
_connectionStringManager.ConfigureTransientConnectionString(defaultConnection, transientDatabase);
var database = new Database();
database.ConfigureAndBuild(_connectionStringManager, new Dictionary <string, object>(), _session);
database.RunScripts("../../../Common/Sql");
_session.Received(2).Execute(Arg.Is(_connectionStringManager.TransientConnectionString),
Arg.Any <string>());
}
public void should_build()
{
IConnectionStringManager connectionStringManager = Substitute.For <IConnectionStringManager>();
connectionStringManager.DefaultConnectionString.Returns("Server=localhost;database=a");
connectionStringManager.TransientConnectionString.Returns("Server=localhost;database=b");
IDatabase database = Substitute.For <IDatabase>();
ISession session = Substitute.For <ISession>();
var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.con.json").Build();
_builder.WithConfiguration(configuration, "AlternateConnection");
_builder.ForVendor(connectionStringManager, database, session);
var summary = _builder.ConfigurationSummary;
Assert.DoesNotThrow(() => _builder.Build());
Assert.AreEqual("Server=localhost;database=b", summary.TransientConnectionString);
}
public void should_call_correct_drop_statements()
{
var defaultConnection = $"Server=localhost;Database={RandomData.RandomWord()}";
var transientDatabase = RandomData.RandomWord();
_connectionStringManager = new ConnectionStringManager();
_connectionStringManager.ConfigureTransientConnectionString(defaultConnection, transientDatabase);
var database = new Database();
database.ConfigureAndBuild(_connectionStringManager, new Dictionary <string, object>(), _session);
database.Drop();
_session.Received(1).Execute(Arg.Is(_connectionStringManager.DefaultConnectionString),
Arg.Is(
$"select pid, pg_terminate_backend(pid) from pg_stat_activity where datname = '{_connectionStringManager.TransientDatabaseName}' and pid <> pg_backend_pid();"));
_session.Received(1).Execute(Arg.Is(_connectionStringManager.DefaultConnectionString),
Arg.Is($"drop database {_connectionStringManager.TransientDatabaseName}"));
}
public SqliteContext(IConnectionStringManager connectionStringManager)
{
_connectionStringManager = connectionStringManager;
}
/// <summary>
/// Creates a new instance of SqlDataStoreBase which uses the specified ISqlDataConnectionProvider
/// to obtain a connection to the database, and the specified IConnectionStringManager to obtain
/// the actual connection string to use to establish that connection, by passing in the value of the
/// base class ConnectionString property.
/// </summary>
/// <param name="provider">The ISqlDataConnectionProvider to use to establish a connection.</param>
/// <param name="connectionStringManager">The IConnectionStringManager to use to convert the value from the ConnectionString property.</param>
protected SqlDataStoreBase(ISqlDataConnectionProvider provider, IConnectionStringManager connectionStringManager)
: base(provider, connectionStringManager)
{
}
public SQLiteSlickRunImporterService(ISlickRunExtractor extractor, ILogService log, IConnectionStringManager csm)
{
_log = log;
_extractor = extractor;
_connectionString = csm.Get();
}
public DataRepository(IConnectionStringManager connectionStringManager)
{
_connectionStringManager = connectionStringManager;
}
protected EfCoreDbContextBase(IConnectionStringManager connectionManager)
{
_connectionManager = connectionManager;
}
protected EfCoreDbContextBase(IConnectionStringManager connectionManager, DbContextOptions options)
: base(options)
{
_connectionManager = connectionManager;
}
/// <summary>
/// Creates a new instance of EntityFrameworkDataStoreBase.
/// </summary>
/// <param name="provider"></param>
/// <param name="connectionStringManager"></param>
protected EntityFrameworkCoreDataStoreBase(IEntityFrameworkCoreDataConnectionProvider <TContext> provider, IConnectionStringManager connectionStringManager)
: base(provider, connectionStringManager)
{
}
public void Setup()
{
_connectionStringManager = new ConnectionStringManager();
_session = Substitute.For <ISession>();
}
/// <summary>
/// Creates a new DataStoreBase using the specified Connection Provider and Connection String Manager.
/// </summary>
/// <param name="provider">The provider to use to retrieve an instance of an IDataConnection / TConnection.</param>
/// <param name="connectionStringManager">The connection string manager to use to convert the ConnectionString to an actual connection string.</param>
protected DataStoreBase(IDataConnectionProvider <TConnection> provider, IConnectionStringManager connectionStringManager)
{
_provider = provider;
_connectionStringManager = connectionStringManager;
}
public ConnectionStringManagerTest(WebAppTestFactory factory)
{
connStringManager = factory.Services.GetService <IConnectionStringManager>();
dbOptions = factory.Services.GetService <IOptionsSnapshot <AppDbOptions> >().Value;
}
public SqlServerContext(IConnectionStringManager connectionStringManager)
{
_connectionStringManager = connectionStringManager;
}
public EntityFrameworkExampleDataStore(IEntityFrameworkCoreDataConnectionProvider <ExampleDbContext> provider,
IConnectionStringManager connectionStringManager)
: base(provider, connectionStringManager)
{
}
/// <summary>
/// 构造函数
/// <remarks>
/// <para>此时数据库为SQLSERVER</para>
/// </remarks>
/// </summary>
/// <param name="pConnectionStringManager">连接字符串管理器</param>
public DBDataSource(IConnectionStringManager pConnectionStringManager)
{
this.ConnectionStringManager = pConnectionStringManager;
}
public SqlConnectionFactory(IConnectionStringManager connectionStringManager)
{
_connectionStringManager = connectionStringManager;
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
using (var scope = provider.CreateScope())
{
dbContext = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
geoliteManager = scope.ServiceProvider.GetRequiredService <IGeoliteManager>();
hostEnvironment = scope.ServiceProvider.GetRequiredService <IWebHostEnvironment>();
connectionManager = scope.ServiceProvider.GetRequiredService <IConnectionStringManager>();
// update every 7 days
int updateIntervalInMilliseconds = TimeSpan.FromDays(7).Milliseconds;
dbContext.Database.EnsureCreated();
if (!dbContext.GeoObjects.Any())
{
FillDatabase();
// install timer to UpdateDatabase every 7 days
timer = new Timer(async(obj) =>
await UpdateDatabaseAsync(), null, updateIntervalInMilliseconds, updateIntervalInMilliseconds);
}
else
{
GeoObject geoObject = await dbContext.GeoObjects.FirstOrDefaultAsync();
DateTime lastUpdateTime = geoObject.UpdateTime;
DateTime currentTime = DateTime.UtcNow;
DateTime nextUpdateTime = CalculateNextUpdateTime(currentTime);
TimeSpan dayPassed = currentTime - lastUpdateTime;
DateTime dateToUpdate = nextUpdateTime - dayPassed;
TimeSpan daysLeft = dateToUpdate - currentTime;
if (daysLeft.Days > 0)
{
// install timer to UpdateDatabase when left days will pass and set interval to repeat this action every 7 days
// so we update our DB every week (Wednesday)
timer = new Timer(async(obj) =>
await UpdateDatabaseAsync(), null, daysLeft.Milliseconds, updateIntervalInMilliseconds);
}
else
{ // install timer to UpdateDatabase now and set interval to repeat this action every 7 days
// so we update our DB every week (Wednesday)
timer = new Timer(async(obj) =>
await UpdateDatabaseAsync(), null, 0, updateIntervalInMilliseconds);
}
}
}
DateTime CalculateNextUpdateTime(DateTime currentTime)
=> currentTime.DayOfWeek switch
{
DayOfWeek.Sunday => currentTime + TimeSpan.FromDays(3),
DayOfWeek.Monday => currentTime + TimeSpan.FromDays(2),
DayOfWeek.Tuesday => currentTime + TimeSpan.FromDays(1),
DayOfWeek.Wednesday => currentTime,
DayOfWeek.Thursday => currentTime + TimeSpan.FromDays(6),
DayOfWeek.Friday => currentTime + TimeSpan.FromDays(5),
DayOfWeek.Saturday => currentTime + TimeSpan.FromDays(4),
_ => currentTime
};
// since we have no data in DB we should not call this method in async mode
// because we first should migrate data to our DB and don't let any controller to be able to access DB before we
// so this is why it's better to do it in sync
// because we don't want our API work when DB is empty
void FillDatabase()
{
var root = hostEnvironment.ContentRootPath;
var directory = Path.Combine(root, "Geolite");
Directory.CreateDirectory(directory);
string geoliteDb = geoliteManager.DownloadDbFileAsync(directory).Result;
geoliteManager.MigrateToDbContext(geoliteDb, dbContext).Wait();
}
async Task UpdateDatabaseAsync()
{
var root = hostEnvironment.ContentRootPath;
var directory = Path.Combine(root, "Geolite");
Directory.CreateDirectory(directory);
string geoliteDb = await geoliteManager.DownloadDbFileAsync(directory);
#region Migrate geoliteDb to new Database
string newDatabaseConnection = connectionManager.GenerateNewConnectionString();
var newDbConnectionBuilder = new DbContextOptionsBuilder <ApplicationContext>();
newDbConnectionBuilder.UseNpgsql(newDatabaseConnection);
using (var context = new ApplicationContext(newDbConnectionBuilder.Options))
{
await context.Database.EnsureCreatedAsync();
await geoliteManager.MigrateToDbContext(geoliteDb, context);
}
#endregion
// get currentDbConnection so that to delete
// because we already created new DB
string outdatedConnectionString = connectionManager.ConnectionString;
// set CurrentConnectionString to our new DB
connectionManager.ConnectionString = newDatabaseConnection;
#region Delete outdated Database
var outdatedDbBuilder = new DbContextOptionsBuilder <ApplicationContext>();
outdatedDbBuilder.UseNpgsql(outdatedConnectionString);
using (var outdatedContext = new ApplicationContext(outdatedDbBuilder.Options))
{
await outdatedContext.Database.EnsureDeletedAsync();
}
#endregion
}
}
}
public ConnectionStringSettings(IConnectionStringManager connectionStringManager)
{
_connectionStringManager = connectionStringManager;
}
public SqlConnectionFactory(IConnectionStringManager connectionStringManager)
{
// Validate parameters.
_connectionStringManager = connectionStringManager ?? throw new ArgumentNullException(nameof(connectionStringManager));
}
