static AuthDatabase()
{
var config = Config.Instance.AuthDatabase;
DataAccessModelConfiguration dbConfig;
switch (Config.Instance.AuthDatabase.Engine)
{
case DatabaseEngine.MySQL:
dbConfig = MySqlConfiguration.Create(config.Database, config.Host, config.Username, config.Password, true);
break;
case DatabaseEngine.SQLite:
dbConfig = SqliteConfiguration.Create(config.Filename, null);
break;
default:
Logger.Error()
.Message("Invalid database engine {0}", Config.Instance.AuthDatabase.Engine)
.Write();
Environment.Exit(0);
return;
}
Instance = DataAccessModel.BuildDataAccessModel <Database.Auth.AuthDatabase>(dbConfig);
}
public IdentityModelTests()
{
this.model = DataAccessModel.BuildDataAccessModel <IdentityModel>(SqliteConfiguration.Create(":memory:", null, BaseTests <IdentityModel> .useMonoData));
this.model.Create(DatabaseCreationOptions.IfDatabaseNotExist);
this.userStore = new ShaolinqIdentityUserStore <ShaolinqIdentityUser <Guid>, IdentityModel, Guid, DbUser, DbUserLogin, DbUserClaim, DbUserRole>(this.model);
}
/// <summary>
/// Use Sqlite for the Outbox
/// </summary>
/// <param name="brighterBuilder">Allows extension method syntax</param>
/// <param name="configuration">The connection for the Db and name of the Outbox table</param>
/// <param name="connectionProvider">What is the type for the class that lets us obtain connections for the Sqlite database</param>
/// <param name="serviceLifetime">What is the lifetime of the services that we add</param>
/// <returns>Allows fluent syntax</returns>
/// Registers the following
/// -- SqliteOutboxConfigutation: connection string and outbox name
/// -- ISqliteConnectionProvider: lets us get a connection for the outbox that matches the entity store
/// -- IAmAnOutbox<Message>: an outbox to store messages we want to send
/// -- IAmAnOutboxAsync<Message>: an outbox to store messages we want to send
/// -- IAmAnOutboxViewer<Message>: Lets us read the entries in the outbox
/// -- IAmAnOutboxViewerAsync<Message>: Lets us read the entries in the outbox
public static IBrighterBuilder UseSqliteOutbox(
this IBrighterBuilder brighterBuilder, SqliteConfiguration configuration, Type connectionProvider, ServiceLifetime serviceLifetime = ServiceLifetime.Singleton)
{
brighterBuilder.Services.AddSingleton <SqliteConfiguration>(configuration);
brighterBuilder.Services.Add(new ServiceDescriptor(typeof(ISqliteConnectionProvider), connectionProvider, serviceLifetime));
brighterBuilder.Services.Add(new ServiceDescriptor(typeof(IAmAnOutboxSync <Message>), BuildSqliteOutbox, serviceLifetime));
brighterBuilder.Services.Add(new ServiceDescriptor(typeof(IAmAnOutboxAsync <Message>), BuildSqliteOutbox, serviceLifetime));
return(brighterBuilder);
}
public void StartInit()
{
_netManager.RegisterNetMessage <MsgPreferencesAndSettings>(nameof(MsgPreferencesAndSettings));
_netManager.RegisterNetMessage <MsgSelectCharacter>(nameof(MsgSelectCharacter),
HandleSelectCharacterMessage);
_netManager.RegisterNetMessage <MsgUpdateCharacter>(nameof(MsgUpdateCharacter),
HandleUpdateCharacterMessage);
_configuration.RegisterCVar("game.maxcharacterslots", 10);
_configuration.RegisterCVar("database.prefs_engine", "sqlite");
_configuration.RegisterCVar("database.prefs_sqlite_dbpath", "preferences.db");
_configuration.RegisterCVar("database.prefs_pg_host", "localhost");
_configuration.RegisterCVar("database.prefs_pg_port", 5432);
_configuration.RegisterCVar("database.prefs_pg_database", "ss14_prefs");
_configuration.RegisterCVar("database.prefs_pg_username", string.Empty);
_configuration.RegisterCVar("database.prefs_pg_password", string.Empty);
var engine = _configuration.GetCVar <string>("database.prefs_engine").ToLower();
IDatabaseConfiguration dbConfig;
switch (engine)
{
case "sqlite":
var configPreferencesDbPath = _configuration.GetCVar <string>("database.prefs_sqlite_dbpath");
var finalPreferencesDbPath =
Path.Combine(_resourceManager.UserData.RootDir, configPreferencesDbPath);
dbConfig = new SqliteConfiguration(
finalPreferencesDbPath
);
break;
case "postgres":
dbConfig = new PostgresConfiguration(
_configuration.GetCVar <string>("database.prefs_pg_host"),
_configuration.GetCVar <int>("database.prefs_pg_port"),
_configuration.GetCVar <string>("database.prefs_pg_database"),
_configuration.GetCVar <string>("database.prefs_pg_username"),
_configuration.GetCVar <string>("database.prefs_pg_password")
);
break;
default:
throw new NotImplementedException("Unknown database engine {engine}.");
}
var maxCharacterSlots = _configuration.GetCVar <int>("game.maxcharacterslots");
// Actually loading the preferences database takes a while,
// because EFCore has to initialize and run migrations.
// We load it in the thread pool here and then fetch the .Result in FinishInit.
// This means it'll run in parallel with other loading like prototypes & map load.
_prefsDbLoadTask = Task.Run(() => new PreferencesDatabase(dbConfig, maxCharacterSlots));
}
protected DataAccessModelConfiguration CreateSqliteConfiguration(string databaseName)
{
var retval = SqliteConfiguration.Create(databaseName + ".db", null, useMonoData);
retval.AlwaysSubmitDefaultValues = this.alwaysSubmitDefaultValues;
retval.ValueTypesAutoImplicitDefault = this.valueTypesAutoImplicitDefault;
retval.SaveAndReuseGeneratedAssemblies = true;
retval.SqlDatabaseContextInfos[0].SqlDataTypes = new List <Type> {
typeof(SqlFixedDateDataType)
};
return(retval);
}
/// <summary>
/// Update configuration parameters.
/// </summary>
/// <param name="configuration">The data access configuration.</param>
public void Configure(SqliteConfiguration configuration)
{
ThrowIf.Null(configuration, "dataAccessConfiguration");
configuration.Validate();
lock (this)
{
if (this.connectionManager != null)
{
throw new InvalidOperationException("This instance has already been configured and its configuration values cannot be reset.");
}
this.connectionManager = new DataAccess.Sqlite.ConnectionManager(configuration);
}
}
protected DataAccessModelConfiguration CreateSqliteClassicInMemoryConfiguration(string databaseName)
{
return(SqliteConfiguration.Create(":memory:", null, useMonoData));
}
protected DataAccessModelConfiguration CreateSqliteInMemoryConfiguration(string databaseName)
{
return(SqliteConfiguration.Create("file:" + databaseName + "?mode=memory&cache=shared", null, useMonoData));
}
protected DataAccessModelConfiguration CreateSqliteConfiguration(string databaseName)
{
return(SqliteConfiguration.Create(databaseName + ".db", null, useMonoData));
}
public void TestCreateDataAccessModel()
{
var dataModel = DataAccessModel.BuildDataAccessModel <IdentityServerDataAccessModel>(SqliteConfiguration.Create(":memory:", null));
dataModel.Create(DatabaseCreationOptions.DeleteExistingDatabase);
}
/// <summary>
/// Initializes a new instance of the <see cref="SqliteOutboxSync" /> class.
/// </summary>
/// <param name="configuration">The configuration to connect to this data store</param>
public SqliteOutboxSync(SqliteConfiguration configuration) : this(configuration, new SqliteConnectionProvider(configuration))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SqliteOutboxSync" /> class.
/// </summary>
/// <param name="configuration">The configuration to connect to this data store</param>
/// <param name="connectionProvider">Provides a connection to the Db that allows us to enlist in an ambient transaction</param>
public SqliteOutboxSync(SqliteConfiguration configuration, ISqliteConnectionProvider connectionProvider)
{
_configuration = configuration;
ContinueOnCapturedContext = false;
_connectionProvider = connectionProvider;
}
public StatisticContext(SqliteConfiguration configuration) : base(configuration)
{
}
public BeatmapDownloaderDatabaseContext(SqliteConfiguration configuration) : base(configuration)
{
}
public OsuDatabaseContext(SqliteConfiguration config) : base(config)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ConnectionManager"/> class.
/// </summary>
/// <param name="configuration">The configuration object.</param>
internal ConnectionManager(SqliteConfiguration configuration)
{
this.configuration = configuration;
this.connectionDictionary = new Dictionary <string, LinkedList <DatabaseConnection> >(StringComparer.OrdinalIgnoreCase);
}
