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); }