public SchemaCollection<StoredProcedureModel> Extract( DatabaseConfiguration configuration, StoredProcedureCollection procedures) { Dictionary<string, StoredProcedure> storedProcedureLookup = CreateLookup(procedures); using (var connection = new SqlConnection(_connectionStringProvider.ConnectionString)) { connection.Open(); var collection = new SchemaCollection<StoredProcedureModel>( _schemaElementCollectionBuilder, configuration.StoredProcedures.Namespace); foreach (var element in configuration.StoredProcedures.Elements) { string escapedFullName = _nameConverter.EscapeDatabaseName(element.SchemaName, element.Name); if (storedProcedureLookup.ContainsKey(escapedFullName)) { StoredProcedure procedure = storedProcedureLookup[escapedFullName]; StoredProcedureModel model = ToModel(connection, configuration, procedure); collection.AddElement(procedure.Schema, model); } else { throw new ArgumentException(string.Format("Unable to locate stored procedure '{0}'", escapedFullName)); } } return collection; } }
public static void StartDatabase() { if (Utilities.ConfigurationManager.GetStringValue("SQLUsername") == "root") { Utilities.ConsoleStyle.Warning(@"'root' Username is not safe, please modify this for your security"); } var config = new DatabaseConfiguration(DatabaseType.MySQL, Utilities.ConfigurationManager.GetStringValue("SQLHost"), Utilities.ConfigurationManager.GetStringValue("SQLDB"), Utilities.ConfigurationManager.GetStringValue("SQLUsername"), Utilities.ConfigurationManager.GetStringValue("SQLPassword")); var source = new InPlaceConfigurationSource(); source.Add(typeof(ActiveRecordBase), config.GetProperties()); ActiveRecordStarter.Initialize(source, typeof(CharacterRecord), typeof(MapRecords), typeof(TriggerRecord), typeof(ItemRecord), typeof(WorldItemRecord), typeof(NpcRecord), typeof(NpcPositionRecord), typeof(NpcDialogRecord), typeof(ZaapRecord), typeof(AccountDataRecord), typeof(OriginalBreedStartMapRecord), typeof(IncarnamTeleportRecord), typeof(ExpFloorRecord), typeof(BaseSpellRecord), typeof(MonstersTemplateRecord), typeof(MonsterLevelRecord), typeof(MountTemplateRecord), typeof(GuildCreatorLocationRecord), typeof(SpellRecord), typeof(ShopItemRecord), typeof(BreedRecord), typeof(GuildRecord), typeof(DungeonRoomRecord), typeof(WorldMountRecord), typeof(PaddockRecord), typeof(DropRecord), typeof(BannedAccountRecord), typeof(ElitesRecord), typeof(LiveActionRecord), typeof(HotelRecord), typeof(ServerInfoRecord), typeof(ItemSetRecord), typeof(IODataRecord), typeof(JobDataRecord), typeof(CraftRecord), typeof(ItemBagRecord), typeof(AuctionHouseRecord), typeof(AuctionHouseItemRecord)); }
public void InsertMusicSheet(MusicSheet sheet) { var config = new DatabaseConfiguration("mongodb://*****:*****@staff.mongohq.com:10013/") { DatabaseName = "MusicCatalog" }; var databaseAccess = new DatabaseAccess(config); databaseAccess.SaveOne(sheet); }
public MusicSheet GetMusicSheetByFriendlyId(string friendlyId) { var config = new DatabaseConfiguration("mongodb://*****:*****@staff.mongohq.com:10013/") { DatabaseName = "MusicCatalog" }; var databaseAccess = new DatabaseAccess(config); var sheet = databaseAccess.GetSingle<MusicSheet>(friendlyId); return sheet; }
public static void StartDatabase() { var config = new DatabaseConfiguration(DatabaseType.MySQL, Utilities.ConfigurationManager.GetStringValue("SQLHost"), Utilities.ConfigurationManager.GetStringValue("SQLDB"), Utilities.ConfigurationManager.GetStringValue("SQLUsername"), Utilities.ConfigurationManager.GetStringValue("SQLPassword")); var source = new InPlaceConfigurationSource(); source.Add(typeof(ActiveRecordBase), config.GetProperties()); ActiveRecordStarter.Initialize(source, typeof(AccountRecord), typeof(GameServerRecord), typeof(AccountCharactersInformationsRecord)); }
public RepositoryFactory(DatabaseConfiguration databaseConfiguration, string dataDirectory) { var connectionStringBuilder = new MySqlConnectionStringBuilder(); connectionStringBuilder.UserID = databaseConfiguration.Username; connectionStringBuilder.Password = databaseConfiguration.Password; connectionStringBuilder.Server = databaseConfiguration.Server; connectionStringBuilder.Database = databaseConfiguration.Database; connectionStringBuilder.Port = databaseConfiguration.Port; _connectionString = connectionStringBuilder.ToString(); _dataDirectory = dataDirectory; }
public MicroCore(DatabaseConfiguration dbConf, AssemblyManager assemblyLoader, MicroCoreEventDispatcher dispatcher, MicroBoot microBoot, I18NService i18nService, FileUpdate fileUpdate) { this.microBoot = microBoot; this.dbConf = dbConf; this.assemblyLoader = assemblyLoader; this.dispatcher = dispatcher; this.i18nService = i18nService; this.fileUpdate = fileUpdate; i18nService.ConfigureThreadI18n(System.Threading.Thread.CurrentThread); microBoot.coreShutdownEvent = new ManualResetEvent(false); }
public ProjectManagerDbHelper(ApplicationManager app) : base(app) { Db = DatabaseConfiguration.Build().UsingConnectionString(Parameters.Parameters.ProjectManagerDbConnectionString) .UsingProvider(new PostgreSQLDatabaseProvider()).Create(); }
internal Database(uint dbi, IntPtr env, string name, Action <Database> disposed, DatabaseConfiguration config) { this.dbi = dbi; this.env = env; this.Name = name; this.disposed = disposed; this.Config = config; }
public void TransactionShouldSupportCustomComparer() { Func<int, int, int> comparison = (l, r) => l.CompareTo(r); var options = new DatabaseConfiguration {Flags = DatabaseOpenFlags.Create}; Func<byte[], byte[], int> compareWith = (l, r) => comparison(BitConverter.ToInt32(l, 0), BitConverter.ToInt32(r, 0)); options.CompareWith(Comparer<byte[]>.Create(new Comparison<byte[]>(compareWith))); using (var txnT = _env.BeginTransaction()) using (var db1 = txnT.OpenDatabase(configuration: options)) { txnT.DropDatabase(db1); txnT.Commit(); } var txn = _env.BeginTransaction(); var db = txn.OpenDatabase(configuration: options); var keysUnsorted = Enumerable.Range(1, 10000).OrderBy(x => Guid.NewGuid()).ToList(); var keysSorted = keysUnsorted.ToArray(); Array.Sort(keysSorted, new Comparison<int>(comparison)); GC.Collect(); for (var i = 0; i < keysUnsorted.Count; i++) txn.Put(db, BitConverter.GetBytes(keysUnsorted[i]), BitConverter.GetBytes(i)); using (var c = txn.CreateCursor(db)) { int order = 0; while (c.MoveNext()) Assert.Equal(keysSorted[order++], BitConverter.ToInt32(c.Current.Key, 0)); } }
public EatingDayRepository(DatabaseConfiguration configuration) : base(configuration) { }
public GlobalConfiguration(CommunicationConfiguration communicationConfiguration, DatabaseConfiguration databaseConfiguration, RouteConfiguration routeConfiguration) { CommunicationConfiguration = communicationConfiguration; DatabaseConfiguration = databaseConfiguration; RouteConfiguration = routeConfiguration; }
public DatabaseConfigurationProvider(IOptions <DatabaseConfiguration> config) { _databaseConfiguration = config.Value; }
public FileProcessed() { configuration = new DatabaseConfiguration(); mapper = new Mapper(); }
public void TransactionShouldSupportCustomComparer() { Func<int, int, int> comparison = (l, r) => -Math.Sign(l - r); var txn = _env.BeginTransaction(); var options = new DatabaseConfiguration {Flags = DatabaseOpenFlags.Create}; Func<byte[], byte[], int> compareWith = (l, r) => comparison(BitConverter.ToInt32(l, 0), BitConverter.ToInt32(r, 0)); options.CompareWith(Comparer<byte[]>.Create(new Comparison<byte[]>(compareWith))); var db = txn.OpenDatabase(configuration: options); var keysUnsorted = new [] { 2, 10, 5 }; var keysSorted = keysUnsorted.ToArray(); Array.Sort(keysSorted, new Comparison<int>(comparison)); for (var i = 0; i < keysUnsorted.Length; i++) txn.Put(db, BitConverter.GetBytes(keysUnsorted[i]), BitConverter.GetBytes(i)); using (var c = txn.CreateCursor(db)) { int order = 0; while (c.MoveNext()) Assert.Equal(keysSorted[order++], BitConverter.ToInt32(c.Current.Key, 0)); } }
/// <summary> /// Construct a <see cref="DatabaseContext{TParentContext}"/> /// </summary> /// <param name="dbContextOptions">The <see cref="DbContextOptions{TParentContext}"/> for the <see cref="DatabaseContext{TParentContext}"/></param> /// <param name="databaseConfigurationOptions">The <see cref="IOptions{TOptions}"/> containing the value of <see cref="DatabaseConfiguration"/></param> /// <param name="databaseSeeder">The value of <see cref="databaseSeeder"/></param> /// <param name="logger">The value of <see cref="Logger"/></param> public DatabaseContext(DbContextOptions <TParentContext> dbContextOptions, IOptions <DatabaseConfiguration> databaseConfigurationOptions, IDatabaseSeeder databaseSeeder, ILogger logger) : base(dbContextOptions) { DatabaseConfiguration = databaseConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(databaseConfigurationOptions)); this.databaseSeeder = databaseSeeder ?? throw new ArgumentNullException(nameof(databaseSeeder)); Logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public Startup(IConfiguration configuration) { Configuration = configuration; JwtConfiguration = new JwtConfiguration(); DbConfiguration = new DatabaseConfiguration(); }
public UserCredential() { configuration = new DatabaseConfiguration(); mapper = new Mapper(); }
/// <summary> /// Prompts the user to create a <see cref="DatabaseConfiguration"/> /// </summary> /// <param name="cancellationToken">The <see cref="CancellationToken"/> for the operation</param> /// <returns>A <see cref="Task{TResult}"/> resulting in the new <see cref="DatabaseConfiguration"/></returns> #pragma warning disable CA1502 // TODO: Decomplexify async Task <DatabaseConfiguration> ConfigureDatabase(CancellationToken cancellationToken) { bool firstTime = true; do { await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); var databaseConfiguration = new DatabaseConfiguration { DatabaseType = await PromptDatabaseType(firstTime, cancellationToken).ConfigureAwait(false) }; firstTime = false; string serverAddress = null; ushort?serverPort = null; bool isSqliteDB = databaseConfiguration.DatabaseType == DatabaseType.Sqlite; if (!isSqliteDB) { do { await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("Enter the server's address and port [<server>:<port> or <server>] (blank for local): ", false, cancellationToken).ConfigureAwait(false); serverAddress = await console.ReadLineAsync(false, cancellationToken).ConfigureAwait(false); if (String.IsNullOrWhiteSpace(serverAddress)) { serverAddress = null; } else if (databaseConfiguration.DatabaseType == DatabaseType.SqlServer) { var match = Regex.Match(serverAddress, @"^(?<server>.+):(?<port>.+)$"); if (match.Success) { serverAddress = match.Groups["server"].Value; var portString = match.Groups["port"].Value; if (UInt16.TryParse(portString, out var port)) { serverPort = port; } else { await console.WriteAsync($"Failed to parse port \"{portString}\", please try again.", true, cancellationToken).ConfigureAwait(false); continue; } } } break; }while (true); } await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync($"Enter the database {(isSqliteDB ? "file path" : "name")} (Can be from previous installation. Otherwise, should not exist): ", false, cancellationToken).ConfigureAwait(false); string databaseName; bool dbExists = false; do { databaseName = await console.ReadLineAsync(false, cancellationToken).ConfigureAwait(false); if (!String.IsNullOrWhiteSpace(databaseName)) { if (isSqliteDB) { dbExists = await ioManager.FileExists(databaseName, cancellationToken).ConfigureAwait(false); if (!dbExists) { databaseName = await ValidateNonExistantSqliteDBName(databaseName, cancellationToken).ConfigureAwait(false); } } else { dbExists = await PromptYesNo("Does this database already exist? If not, we will attempt to CREATE it. (y/n): ", cancellationToken).ConfigureAwait(false); } } if (String.IsNullOrWhiteSpace(databaseName)) { await console.WriteAsync("Invalid database name!", true, cancellationToken).ConfigureAwait(false); } else { break; } }while (true); bool useWinAuth; if (databaseConfiguration.DatabaseType == DatabaseType.SqlServer && platformIdentifier.IsWindows) { useWinAuth = await PromptYesNo("Use Windows Authentication? (y/n): ", cancellationToken).ConfigureAwait(false); } else { useWinAuth = false; } await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); string username = null; string password = null; if (!isSqliteDB) { if (!useWinAuth) { await console.WriteAsync("Enter username: "******"Enter password: "******"IMPORTANT: If using the service runner, ensure this computer's LocalSystem account has CREATE DATABASE permissions on the target server!", true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("The account it uses in MSSQL is usually \"NT AUTHORITY\\SYSTEM\" and the role it needs is usually \"dbcreator\".", true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("We'll run a sanity test here, but it won't be indicative of the service's permissions if that is the case", true, cancellationToken).ConfigureAwait(false); } } await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); DbConnection testConnection; void CreateTestConnection(string connectionString) => testConnection = dbConnectionFactory.CreateConnection( connectionString, databaseConfiguration.DatabaseType); switch (databaseConfiguration.DatabaseType) { case DatabaseType.SqlServer: { var csb = new SqlConnectionStringBuilder { ApplicationName = assemblyInformationProvider.VersionPrefix, DataSource = serverAddress ?? "(local)" }; if (useWinAuth) { csb.IntegratedSecurity = true; } else { csb.UserID = username; csb.Password = password; } CreateTestConnection(csb.ConnectionString); csb.InitialCatalog = databaseName; databaseConfiguration.ConnectionString = csb.ConnectionString; } break; case DatabaseType.MariaDB: case DatabaseType.MySql: { // MySQL/MariaDB var csb = new MySqlConnectionStringBuilder { Server = serverAddress ?? "127.0.0.1", UserID = username, Password = password }; if (serverPort.HasValue) { csb.Port = serverPort.Value; } CreateTestConnection(csb.ConnectionString); csb.Database = databaseName; databaseConfiguration.ConnectionString = csb.ConnectionString; } break; case DatabaseType.Sqlite: { var csb = new SqliteConnectionStringBuilder { DataSource = databaseName, Mode = dbExists ? SqliteOpenMode.ReadOnly : SqliteOpenMode.ReadWriteCreate }; CreateTestConnection(csb.ConnectionString); databaseConfiguration.ConnectionString = csb.ConnectionString; } break; case DatabaseType.PostgresSql: { var csb = new NpgsqlConnectionStringBuilder { ApplicationName = assemblyInformationProvider.VersionPrefix, Host = serverAddress ?? "127.0.0.1", Password = password, Username = username }; if (serverPort.HasValue) { csb.Port = serverPort.Value; } CreateTestConnection(csb.ConnectionString); csb.Database = databaseName; databaseConfiguration.ConnectionString = csb.ConnectionString; } break; default: throw new InvalidOperationException("Invalid DatabaseType!"); } try { await TestDatabaseConnection(testConnection, databaseConfiguration, databaseName, dbExists, cancellationToken).ConfigureAwait(false); return(databaseConfiguration); } catch (OperationCanceledException) { throw; } catch (Exception e) { await console.WriteAsync(e.Message, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("Retrying database configuration...", true, cancellationToken).ConfigureAwait(false); } }while (true); }
/// <summary> /// Ensure a given <paramref name="testConnection"/> works. /// </summary> /// <param name="testConnection">The test <see cref="DbConnection"/>.</param> /// <param name="databaseConfiguration">The <see cref="DatabaseConfiguration"/> may have derived data populated.</param> /// <param name="databaseName">The database name (or path in the case of a <see cref="DatabaseType.Sqlite"/> database).</param> /// <param name="dbExists">Whether or not the database exists.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/> for the operation.</param> /// <returns>A <see cref="Task"/> representing the running operation.</returns> async Task TestDatabaseConnection( DbConnection testConnection, DatabaseConfiguration databaseConfiguration, string databaseName, bool dbExists, CancellationToken cancellationToken) { bool isSqliteDB = databaseConfiguration.DatabaseType == DatabaseType.Sqlite; using (testConnection) { await console.WriteAsync("Testing connection...", true, cancellationToken).ConfigureAwait(false); await testConnection.OpenAsync(cancellationToken).ConfigureAwait(false); await console.WriteAsync("Connection successful!", true, cancellationToken).ConfigureAwait(false); if (databaseConfiguration.DatabaseType == DatabaseType.MariaDB || databaseConfiguration.DatabaseType == DatabaseType.MySql) { await console.WriteAsync("Checking MySQL/MariaDB version...", true, cancellationToken).ConfigureAwait(false); using var command = testConnection.CreateCommand(); command.CommandText = "SELECT VERSION()"; var fullVersion = (string)await command.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false); await console.WriteAsync(String.Format(CultureInfo.InvariantCulture, "Found {0}", fullVersion), true, cancellationToken).ConfigureAwait(false); var splits = fullVersion.Split('-'); databaseConfiguration.MySqlServerVersion = splits.First(); } if (!isSqliteDB && !dbExists) { await console.WriteAsync("Testing create DB permission...", true, cancellationToken).ConfigureAwait(false); using (var command = testConnection.CreateCommand()) { // I really don't care about user sanitization here, they want to f**k their own DB? so be it #pragma warning disable CA2100 // Review SQL queries for security vulnerabilities command.CommandText = $"CREATE DATABASE {databaseName}"; #pragma warning restore CA2100 // Review SQL queries for security vulnerabilities await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false); } await console.WriteAsync("Success!", true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("Dropping test database...", true, cancellationToken).ConfigureAwait(false); using (var command = testConnection.CreateCommand()) { #pragma warning disable CA2100 // Review SQL queries for security vulnerabilities command.CommandText = $"DROP DATABASE {databaseName}"; #pragma warning restore CA2100 // Review SQL queries for security vulnerabilities try { await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false); } catch (OperationCanceledException) { throw; } catch (Exception e) { await console.WriteAsync(e.Message, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("This should be okay, but you may want to manually drop the database before continuing!", true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("Press any key to continue...", true, cancellationToken).ConfigureAwait(false); await console.PressAnyKeyAsync(cancellationToken).ConfigureAwait(false); } } } } if (isSqliteDB && !dbExists) { await Task.WhenAll( console.WriteAsync("Deleting test database file...", true, cancellationToken), ioManager.DeleteFile(databaseName, cancellationToken)).ConfigureAwait(false); } }
public void PopulateDatabaseConfiguration(Dictionary <string, object> configValues, out ICloneable configuration) { DatabaseConfiguration dbConf = new DatabaseConfiguration(); string databaseName = ""; DatabaseConfiguration remoteDatabase = null; string errorMessage = null; if (_objType == DataDefinitionType.Alter) { if (configValues.ContainsKey(ConfigType.Name.ToString())) { databaseName = configValues[ConfigType.Name.ToString()] as string; } #region Get Database Configuration from Configuraiton Server ClusterConfiguration clusterConfig = _session.GetDatabaseClusterConfiguration(_cluster); if (clusterConfig != null) { if (clusterConfig.Databases != null) { if (clusterConfig.Databases.ContainsDatabase(databaseName)) { remoteDatabase = clusterConfig.Databases.GetDatabase(databaseName); } else { errorMessage = string.Format("Specified database {0} does not exist.", databaseName); } } else { errorMessage = string.Format("Specified database {0} does not exist.", databaseName); } } else { errorMessage = string.Format("No configuraiton exist for cluster {0}", _cluster); } if (remoteDatabase == null) { throw new DatabaseException(ErrorCodes.Query.INVALID_DDL_CONFIGURATION, new string[] { errorMessage }); } #endregion errorMessage = null; if (configValues.ContainsKey(ConfigType.MultiFile.ToString()) && errorMessage == null) { long maxFileSize = GetInt64(ConfigType.MaxFileSize.ToString(), configValues[ConfigType.MaxFileSize.ToString()]); if (maxFileSize * MB > long.MaxValue || maxFileSize * MB < long.MinValue) { throw new DatabaseException(ErrorCodes.Query.INVALID_DDL_CONFIGURATION, new string[] { "Value must be within the range of Int64 for attribute MaxFileSize." }); } if (remoteDatabase.Storage.StorageProvider.MaxFileSize != MB * maxFileSize) { ; } errorMessage = "MultiFile"; } if (configValues.ContainsKey(ConfigType.MaxFileSize.ToString()) && errorMessage == null) { if (remoteDatabase.Storage.StorageProvider.MaxFileSize != MB * GetInt64(ConfigType.MaxFileSize.ToString(), configValues[ConfigType.MaxFileSize.ToString()])) { errorMessage = "MaxFileSize"; } } if (configValues.ContainsKey(ConfigType.MaxCollections.ToString()) && errorMessage == null && remoteDatabase.Storage.StorageProvider.LMDBProvider != null) { if (remoteDatabase.Storage.StorageProvider.LMDBProvider.MaxCollections != GetInt32(ConfigType.MaxCollections.ToString(), configValues[ConfigType.MaxCollections.ToString()])) { errorMessage = "MaxCollections"; } } if (configValues.ContainsKey(ConfigType.InitialSize.ToString()) && errorMessage == null && remoteDatabase.Storage.StorageProvider.LMDBProvider != null) { long initialSize = GetInt64(ConfigType.InitialSize.ToString(), configValues[ConfigType.InitialSize.ToString()]); if (initialSize * MB > long.MaxValue || initialSize * MB < long.MinValue) { throw new DatabaseException(ErrorCodes.Query.INVALID_DDL_CONFIGURATION, new string[] { "Value must be within the range of Int64 for attribute InitialSize." }); } } if (configValues.ContainsKey(ConfigType.CacheSize.ToString()) && errorMessage == null) { long cacheSize = GetInt64(ConfigType.CacheSize.ToString(), configValues[ConfigType.CacheSize.ToString()]); if (cacheSize * MB > long.MaxValue || cacheSize * MB < long.MinValue) { throw new DatabaseException(ErrorCodes.Query.INVALID_DDL_CONFIGURATION, new string[] { "Value must be within the range of Int64 for attribute CacheSize." }); } if (remoteDatabase.Storage.CacheConfiguration.CacheSpace != MB * cacheSize) { errorMessage = "CacheSize"; } } if (errorMessage != null) { throw new DatabaseException(ErrorCodes.Query.INVALID_DDL_CONFIGURATION, new string[] { "Configuration attribute " + errorMessage + " is not Modifiable." }); } dbConf = remoteDatabase; } else { if (configValues.ContainsKey(ConfigType.Name.ToString())) { dbConf.Name = configValues[ConfigType.Name.ToString()] as string; } dbConf.Storage = new StorageConfiguration { Collections = new CollectionConfigurations(), StorageProvider = new StorageProviderConfiguration() }; dbConf.Storage.StorageProvider.LMDBProvider = new LMDBConfiguration(); dbConf.Storage.StorageProvider.StorageProviderType = ProviderType.LMDB; if (configValues.ContainsKey(ConfigType.MultiFile.ToString()) && (!(bool)configValues[ConfigType.MultiFile.ToString()])) { dbConf.Storage.StorageProvider.IsMultiFileStore = false; } else { dbConf.Storage.StorageProvider.IsMultiFileStore = true; } if (configValues.ContainsKey(ConfigType.MaxFileSize.ToString())) { long maxFileSize = GetInt64(ConfigType.MaxFileSize.ToString(), configValues[ConfigType.MaxFileSize.ToString()]); if (maxFileSize * MB > long.MaxValue || maxFileSize * MB < long.MinValue) { throw new DatabaseException(ErrorCodes.Query.INVALID_DDL_CONFIGURATION, new string[] { "Value must be within the range of Int64 for attribute MaxFileSize." }); } dbConf.Storage.StorageProvider.MaxFileSize = MB * maxFileSize; } else { //50 Gb... dbConf.Storage.StorageProvider.MaxFileSize = MB * 1024 * 50; } if (configValues.ContainsKey(ConfigType.MaxCollections.ToString()) && dbConf.Storage.StorageProvider.LMDBProvider != null) { dbConf.Storage.StorageProvider.LMDBProvider.MaxCollections = GetInt32(ConfigType.MaxCollections.ToString(), configValues[ConfigType.MaxCollections.ToString()]); } else if (dbConf.Storage.StorageProvider.LMDBProvider != null) { dbConf.Storage.StorageProvider.LMDBProvider.MaxCollections = 1000; } dbConf.Storage.CacheConfiguration = new CachingConfiguration(); dbConf.Storage.CacheConfiguration.CachePolicy = "FCFS"; if (configValues.ContainsKey(ConfigType.CacheSize.ToString())) { long cacheSize = GetInt64(ConfigType.CacheSize.ToString(), configValues[ConfigType.CacheSize.ToString()]); if (cacheSize * MB > long.MaxValue || cacheSize * MB < long.MinValue) { throw new DatabaseException(ErrorCodes.Query.INVALID_DDL_CONFIGURATION, new string[] { "Value must be within the range of Int64 for attribute CacheSize." }); } dbConf.Storage.CacheConfiguration.CacheSpace = MB * cacheSize; } } configuration = dbConf; }
protected bool Equals(DatabaseConfiguration other) { return(string.Equals(DatabasePath, other.DatabasePath)); }
private void WhenReadingFileThatExists() { _configuration = ConfigurationReader.Read("file"); }
/// <summary> /// Configure et référence l'ORM. /// </summary> /// <param name="services">Liste des services.</param> /// <param name="configuration">Configuration.</param> /// <returns>Liste des services.</returns> internal static IServiceCollection AddORM(this IServiceCollection services, IConfiguration configuration) { return(services .AddSingleton((provider) => { // Récupération des options DatabaseConfiguration options = provider .GetService <IOptions <ApplicationConfiguration> >() .Value .Database; // Extraction des types var types = Assembly .GetExecutingAssembly() .GetExportedTypes(); // Création du mappage var mapper = new ModelMapper(); mapper.AddMappings(types); var hbm = mapper.CompileMappingForAllExplicitlyAddedEntities(); // Création de la fabrique var pre = new Configuration(); pre.DataBaseIntegration( db => { // Informations initiales db.ConnectionString = options.ConnectionString; db.BatchSize = options.BatchSize; db.Dialect <MsSql2012Dialect>(); // Gestion du schéma switch (options.Action) { case "Create": db.SchemaAction = SchemaAutoAction.Create; break; case "Recreate": db.SchemaAction = SchemaAutoAction.Recreate; break; case "Update": db.SchemaAction = SchemaAutoAction.Update; break; case "Validate": db.SchemaAction = SchemaAutoAction.Validate; break; default: throw new InternalException("Invalid database action '{0}'", options.Action); } }) .SetNamingStrategy(new NamingStrategy()) .AddMapping(hbm); return pre.BuildSessionFactory(); }) .AddScoped((provider) => { return provider.GetService <ISessionFactory>().OpenSession(); }) .AddScoped((provider) => { return provider.GetService <ISessionFactory>().OpenStatelessSession(); }) .AddScoped <IDbConnection>((provider) => { return provider.GetService <IStatelessSession>().Connection; }) .AddScoped((provider) => new FieldDAO(provider.GetService <ISession>())) .AddScoped((provider) => new TableDAO(provider.GetService <ISession>())) .AddScoped((provider) => new UserDAO(provider.GetService <ISession>())) .AddScoped((provider) => new ViewDAO(provider.GetService <ISession>()))); }
private static void DoTestImpl(LightningEnvironment env, bool useRandomKeys = false) { var numItemsToWrite = 1 * 1000; // One thousand //var numItemsToWrite = 10 * 1000; // Ten thousand //var numItemsToWrite = 100 * 1000; // One hundred thousand //var numItemsToWrite = 1 * 1000 * 1000; // 1 million //var numItemsToWrite = 10 * 1000 * 1000; // 10 million var randon = new Random(1773); Console.WriteLine("Using {0} keys", useRandomKeys ? "RANDOM" : "SEQUENTIAL"); var writeTimer = Stopwatch.StartNew(); // Need to specify DatabaseOpenFlags.IntegerKey if we want the items to be sorted, not entirely sure why though, // probably big/little endian related, see http://www.openldap.org/lists/openldap-bugs/201308/msg00050.html var dbConfig = new DatabaseConfiguration { Flags = DatabaseOpenFlags.Create | DatabaseOpenFlags.IntegerKey }; using (var tx = env.BeginTransaction()) using (var db = tx.OpenDatabase("test", dbConfig)) { for (var i = 0; i < numItemsToWrite; ++i) { var key = i; if (useRandomKeys) key = randon.Next(); //tx.Put(db, BitConverter.GetBytes(i), BitConverter.GetBytes(i)); var text = "Some Text plus: 'Key' = " + key.ToString("N0"); // + " " + new String('c', 1000); var data = GetBinaryEncodedString(text); tx.Put(db, BitConverter.GetBytes(key), data); } tx.Commit(); var stats = tx.GetStats(db); Console.WriteLine("Stats\n # Entries: {0:N0}\n Depth: {1}\n Page Size: {2}", stats.ms_entries.ToInt64(), stats.ms_depth, stats.ms_psize); Console.WriteLine(" Branch Pages: {0:N0}\n Leaf Pages: {1}\n Overflow Pages: {2}", stats.ms_branch_pages.ToInt64(), stats.ms_leaf_pages.ToInt64(), stats.ms_overflow_pages.ToInt64()); } writeTimer.Stop(); Console.WriteLine("Took {0,10:N2} ms ({1}) to WRITE {2,9:N0} values ({3,10:N0} WRITES/sec)", writeTimer.Elapsed.TotalMilliseconds, writeTimer.Elapsed, numItemsToWrite, numItemsToWrite / writeTimer.Elapsed.TotalMilliseconds * 1000.0); var readTimer = Stopwatch.StartNew(); var readCounter = 0; using (var tx = env.BeginTransaction()) using (var db = tx.OpenDatabase("test")) { tx.Get(db, BitConverter.GetBytes(int.MinValue)); ValueStructure currentKey = default(ValueStructure); ValueStructure currentValue = default(ValueStructure); using (var cursor = tx.CreateCursor(db)) { while (cursor.MoveNext()) { //var current = cursor.Current; cursor.GetCurrent(out currentKey, out currentValue); unsafe { var keyData = *((int*)(currentKey.data.ToPointer())); int valueLengthSize; var ptr = (byte*)currentValue.data.ToPointer(); var length = Read7BitEncodedInt(ptr, out valueLengthSize); var text = new string((sbyte*)(ptr + valueLengthSize), 0, length, Encoding.UTF8); //Console.WriteLine("{{ Key: {0:N0}, Value: \"{1}\" }}", keyData, text); } readCounter++; } } } readTimer.Stop(); Console.WriteLine("Took {0,10:N2} ms ({1}) to READ {2,9:N0} values ({3,10:N0} READS/sec)", readTimer.Elapsed.TotalMilliseconds, readTimer.Elapsed, readCounter, readCounter / readTimer.Elapsed.TotalMilliseconds * 1000.0); Console.WriteLine(); }
/// <summary> /// Construct a <see cref="DatabaseContext"/> /// </summary> /// <param name="options">The <see cref="DbContextOptions{TContext}"/> for the <see cref="DatabaseContext"/></param> /// <param name="databaseConfigurationOptions">The <see cref="IOptions{TOptions}"/> containing the value of <see cref="databaseConfiguration"/></param> /// <param name="loggerFactory">The value of <see cref="loggerFactory"/></param> /// <param name="hostingEnvironment">The value of <see cref="hostingEnvironment"/></param> public DatabaseContext(DbContextOptions <DatabaseContext> options, IOptions <DatabaseConfiguration> databaseConfigurationOptions, ILoggerFactory loggerFactory, IHostingEnvironment hostingEnvironment) : base(options) { databaseConfiguration = databaseConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(databaseConfigurationOptions)); this.loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory)); this.hostingEnvironment = hostingEnvironment ?? throw new ArgumentNullException(nameof(hostingEnvironment)); }
public QuotationTypesRepositoryTests() { dbConfiguration = new DatabaseConfiguration(); session = dbConfiguration.GetSession(); quotationTypesRepository = new QuotationTypesRepository(session); }
internal static void Configure(DatabaseConfiguration configuration) { _configuration = configuration; }
public Extension() { configuration = new DatabaseConfiguration(); mapper = new Mapper(); }
/// <summary> /// Prompts the user to create a <see cref="DatabaseConfiguration"/> /// </summary> /// <param name="cancellationToken">The <see cref="CancellationToken"/> for the operation</param> /// <returns>A <see cref="Task{TResult}"/> resulting in the new <see cref="DatabaseConfiguration"/></returns> async Task <DatabaseConfiguration> ConfigureDatabase(CancellationToken cancellationToken) { do { await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("What SQL database type will you be using?", true, cancellationToken).ConfigureAwait(false); var databaseConfiguration = new DatabaseConfiguration(); do { await console.WriteAsync(String.Format(CultureInfo.InvariantCulture, "Please enter one of {0}, {1}, or {2}: ", DatabaseType.MariaDB, DatabaseType.SqlServer, DatabaseType.MySql), false, cancellationToken).ConfigureAwait(false); var databaseTypeString = await console.ReadLineAsync(false, cancellationToken).ConfigureAwait(false); if (Enum.TryParse <DatabaseType>(databaseTypeString, out var databaseType)) { databaseConfiguration.DatabaseType = databaseType; break; } await console.WriteAsync("Invalid database type!", true, cancellationToken).ConfigureAwait(false); }while (true); string serverAddress; uint? mySQLServerPort = null; do { await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("Enter the server's address and port [<server>:<port> or <server>] (blank for local): ", false, cancellationToken).ConfigureAwait(false); serverAddress = await console.ReadLineAsync(false, cancellationToken).ConfigureAwait(false); if (String.IsNullOrWhiteSpace(serverAddress)) { serverAddress = null; break; } else if (databaseConfiguration.DatabaseType != DatabaseType.SqlServer) { var m = Regex.Match(serverAddress, @"^(?<server>.+):(?<port>.+)$"); if (m.Success) { serverAddress = m.Groups["server"].Value; if (uint.TryParse(m.Groups["port"].Value, out uint port)) { mySQLServerPort = port; break; } else { await console.WriteAsync($@"Failed to parse port ""{m.Groups["port"].Value}"", please try again.", true, cancellationToken).ConfigureAwait(false); } } else { break; } } else { break; } }while (true); await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("Enter the database name (Can be from previous installation. Otherwise, should not exist): ", false, cancellationToken).ConfigureAwait(false); string databaseName; do { databaseName = await console.ReadLineAsync(false, cancellationToken).ConfigureAwait(false); if (!String.IsNullOrWhiteSpace(databaseName)) { break; } await console.WriteAsync("Invalid database name!", true, cancellationToken).ConfigureAwait(false); }while (true); var dbExists = await PromptYesNo("Does this database already exist? (y/n): ", cancellationToken).ConfigureAwait(false); bool useWinAuth; if (databaseConfiguration.DatabaseType == DatabaseType.SqlServer && platformIdentifier.IsWindows) { useWinAuth = await PromptYesNo("Use Windows Authentication? (y/n): ", cancellationToken).ConfigureAwait(false); } else { useWinAuth = false; } await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); string username = null; string password = null; if (!useWinAuth) { await console.WriteAsync("Enter username: "******"Enter password: "******"IMPORTANT: If using the service runner, ensure this computer's LocalSystem account has CREATE DATABASE permissions on the target server!", true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("The account it uses in MSSQL is usually \"NT AUTHORITY\\SYSTEM\" and the role it needs is usually \"dbcreator\".", true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("We'll run a sanity test here, but it won't be indicative of the service's permissions if that is the case", true, cancellationToken).ConfigureAwait(false); } await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); DbConnection testConnection; void CreateTestConnection(string connectionString) { testConnection = dbConnectionFactory.CreateConnection(connectionString, databaseConfiguration.DatabaseType); } if (databaseConfiguration.DatabaseType == DatabaseType.SqlServer) { var csb = new SqlConnectionStringBuilder { ApplicationName = application.VersionPrefix, DataSource = serverAddress ?? "(local)" }; if (useWinAuth) { csb.IntegratedSecurity = true; } else { csb.UserID = username; csb.Password = password; } CreateTestConnection(csb.ConnectionString); csb.InitialCatalog = databaseName; databaseConfiguration.ConnectionString = csb.ConnectionString; } else { var csb = new MySqlConnectionStringBuilder { Server = serverAddress ?? "127.0.0.1", UserID = username, Password = password }; if (mySQLServerPort.HasValue) { csb.Port = mySQLServerPort.Value; } CreateTestConnection(csb.ConnectionString); csb.Database = databaseName; databaseConfiguration.ConnectionString = csb.ConnectionString; } try { using (testConnection) { await console.WriteAsync("Testing connection...", true, cancellationToken).ConfigureAwait(false); await testConnection.OpenAsync(cancellationToken).ConfigureAwait(false); await console.WriteAsync("Connection successful!", true, cancellationToken).ConfigureAwait(false); if (databaseConfiguration.DatabaseType != DatabaseType.SqlServer) { await console.WriteAsync("Checking MySQL/MariaDB version...", true, cancellationToken).ConfigureAwait(false); using (var command = testConnection.CreateCommand()) { command.CommandText = "SELECT VERSION()"; var fullVersion = (string)await command.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false); await console.WriteAsync(String.Format(CultureInfo.InvariantCulture, "Found {0}", fullVersion), true, cancellationToken).ConfigureAwait(false); var splits = fullVersion.Split('-'); databaseConfiguration.MySqlServerVersion = splits[0]; } } if (!dbExists) { await console.WriteAsync("Testing create DB permission...", true, cancellationToken).ConfigureAwait(false); using (var command = testConnection.CreateCommand()) { // I really don't care about user sanitization here, they want to f**k their own DB? so be it #pragma warning disable CA2100 // Review SQL queries for security vulnerabilities command.CommandText = $"CREATE DATABASE {databaseName}"; #pragma warning restore CA2100 // Review SQL queries for security vulnerabilities await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false); } await console.WriteAsync("Success!", true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("Dropping test database...", true, cancellationToken).ConfigureAwait(false); using (var command = testConnection.CreateCommand()) { #pragma warning disable CA2100 // Review SQL queries for security vulnerabilities command.CommandText = $"DROP DATABASE {databaseName}"; #pragma warning restore CA2100 // Review SQL queries for security vulnerabilities try { await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false); } catch (OperationCanceledException) { throw; } catch (Exception e) { await console.WriteAsync(e.Message, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("This should be okay, but you may want to manually drop the database before continuing!", true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("Press any key to continue...", true, cancellationToken).ConfigureAwait(false); await console.PressAnyKeyAsync(cancellationToken).ConfigureAwait(false); } } } } return(databaseConfiguration); } catch (OperationCanceledException) { throw; } catch (Exception e) { await console.WriteAsync(e.Message, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("Retrying database configuration...", true, cancellationToken).ConfigureAwait(false); } }while (true); }
public DiseaseRepository(DatabaseConfiguration databaseConfiguration) : base(databaseConfiguration) { }
public UptimeCheckRepository(DocumentStoreFactory documentStoreFactory, DatabaseConfiguration databaseConfiguration) { _documentStoreFactory = documentStoreFactory; _databaseConfiguration = databaseConfiguration; }
public Startup(IConfiguration configuration) { Configuration = configuration; _databaseConfiguration = new DatabaseConfiguration(configuration); }
private List<ParameterModel> GetParameters(DatabaseConfiguration configuration, StoredProcedure procedure) { return procedure.Parameters .Cast<StoredProcedureParameter>() .Select(p => ToModel(configuration, p)) .ToList(); }
public ShareRepository(DatabaseConfiguration databaseConfiguration) : base(databaseConfiguration) { }
private StoredProcedureModel ToModel(SqlConnection connection, DatabaseConfiguration configuration, StoredProcedure procedure) { var model = new StoredProcedureModel(); model.DatabaseName = CreateDatabaseName(procedure); model.TypeName = _typeNameBuilder.Build(configuration.StoredProcedures.Namespace, procedure.Name); model.Parameters = GetParameters(configuration, procedure); model.OutputParameters = model.Parameters.Where(p => p.IsOutput).ToList(); model.Results = GetResults(connection, model); return model; }
/// <summary> /// Loads this class form the given configuration node. /// </summary> /// <param name="node">The node.</param> public void LoadFromXml( XmlNode node ) { if ( node != null ) { XmlHelper.ReadAttribute( out applicationRegistryKeyName, node.Attributes[@"applicationRegistryKeyName"] ); XmlHelper.ReadAttribute( out administratorEMailAddress, node.Attributes[@"administratorEMailAddress"] ); XmlHelper.ReadAttribute( out disableLoggingPasswordProtection, node.Attributes[@"disableLoggingPasswordProtection"], false ); XmlHelper.ReadAttribute( out smtpServer, node.Attributes[@"smtpServer"] ); XmlHelper.ReadAttribute( out smtpServerPort, node.Attributes[@"smtpServerPort"] ); XmlHelper.ReadAttribute( out smtpServerUserName, node.Attributes[@"smtpServerUserName"] ); XmlHelper.ReadAttribute( out smtpServerPassword, node.Attributes[@"smtpServerPassword"] ); string s; XmlHelper.ReadAttribute( out s, node.Attributes[@"deletedFilesFolderPath"] ); if ( !string.IsNullOrEmpty( s ) ) { deletedFilesFolderPath = new DirectoryInfo( s ); } // -- XmlNode databaseNode = node.SelectSingleNode( @"database" ); if ( databaseNode != null ) { string connectionStringString = null; int commandTimeoutSeconds = 0; bool traceSqlEnabled = false; string cacheSqlBehaviorText = null; DatabaseConfiguration.DatabaseCacheSqlBehavior cacheSqlBehavior = DatabaseConfiguration.DatabaseCacheSqlBehavior.Partially; XmlHelper.ReadAttribute( out connectionStringString, databaseNode.Attributes[@"connectionString"] ); XmlHelper.ReadAttribute( out commandTimeoutSeconds, databaseNode.Attributes[@"commandTimeoutSeconds"] ); XmlHelper.ReadAttribute( out cacheSqlBehaviorText, databaseNode.Attributes[@"cacheSqlBehavior"] ); if ( !string.IsNullOrEmpty( cacheSqlBehaviorText ) ) { cacheSqlBehavior = (DatabaseConfiguration.DatabaseCacheSqlBehavior) Enum.Parse( typeof( DatabaseConfiguration.DatabaseCacheSqlBehavior ), cacheSqlBehaviorText, true ); } XmlHelper.ReadAttribute( out traceSqlEnabled, databaseNode.Attributes[@"traceSqlEnabled"] ); database = new DatabaseConfiguration( connectionStringString, commandTimeoutSeconds, cacheSqlBehavior, traceSqlEnabled ); } // -- XmlNode webNode = node.SelectSingleNode( @"web" ); if ( webNode != null ) { bool useServerSideViewState = false; string replaceTildeFallback = null; string replaceTildeCompleteFallback = null; bool useCustomErrors = false; XmlHelper.ReadAttribute( out useServerSideViewState, webNode.Attributes[@"useServerSideViewState"] ); XmlHelper.ReadAttribute( out replaceTildeFallback, webNode.Attributes[@"replaceTildeFallback"] ); XmlHelper.ReadAttribute( out replaceTildeCompleteFallback, webNode.Attributes[@"replaceTildeCompleteFallback"] ); XmlHelper.ReadAttribute( out useCustomErrors, webNode.Attributes[@"useCustomErrors"] ); web = new WebConfiguration( useServerSideViewState, replaceTildeFallback, replaceTildeCompleteFallback, useCustomErrors ); } // -- /* <webProxy address="" bypassProxyOnLocal="" > <credentials domain="" userName="" password="" /> <bypassList> <bypass rx="" /> <bypass rx="" /> <bypass rx="" /> <bypass rx="" /> </bypassList> </webProxy> */ XmlNode webProxyNode = node.SelectSingleNode( @"webProxy" ); if ( webProxyNode != null ) { bool hasEnabled = false; bool enabled = false; string address = null; bool hasBypassProxyOnLocal = false; bool bypassProxyOnLocal = false; hasEnabled = webProxyNode.Attributes[@"enabled"] != null; XmlHelper.ReadAttribute( out enabled, webProxyNode.Attributes[@"enabled"] ); XmlHelper.ReadAttribute( out address, webProxyNode.Attributes[@"address"] ); hasBypassProxyOnLocal = webProxyNode.Attributes[@"bypassProxyOnLocal"] != null; XmlHelper.ReadAttribute( out bypassProxyOnLocal, webProxyNode.Attributes[@"bypassProxyOnLocal"] ); // If no address is given, ignore everything else. if ( hasEnabled && enabled && !string.IsNullOrEmpty( address ) ) { WebProxy webProxy = new WebProxy(); webProxy.Address = new Uri( address ); if ( hasBypassProxyOnLocal ) { webProxy.BypassProxyOnLocal = bypassProxyOnLocal; } XmlNode credentialsNode = webProxyNode.SelectSingleNode( @"credentials" ); if ( credentialsNode != null ) { string domain = null; string userName = null; string password = null; XmlHelper.ReadAttribute( out domain, credentialsNode.Attributes[@"domain"] ); XmlHelper.ReadAttribute( out userName, credentialsNode.Attributes[@"userName"] ); XmlHelper.ReadAttribute( out password, credentialsNode.Attributes[@"password"] ); // If no user name is given, ignore the credentials. if ( userName != null && userName.Length > 0 ) { NetworkCredential credentials = new NetworkCredential(); credentials.UserName = userName; credentials.Password = password; credentials.Domain = domain; webProxy.Credentials = credentials; } } XmlNodeList bypassNodes = webProxyNode.SelectNodes( @"bypassList/bypass" ); if ( bypassNodes != null && bypassNodes.Count > 0 ) { List<string> bypassRXs = new List<string>(); foreach ( XmlNode bypassNode in bypassNodes ) { string rx = null; XmlHelper.ReadAttribute( out rx, bypassNode.Attributes[@"rx"] ); if ( rx != null && rx.Length > 0 ) { bypassRXs.Add( rx ); } } if ( bypassRXs.Count > 0 ) { webProxy.BypassList = bypassRXs.ToArray(); } } this.webProxy = webProxy; } } } }
public SiteCommunity() { configuration = new DatabaseConfiguration(); mapper = new Mapper(); }
/// <summary> /// Записать схемы базы данных /// </summary> protected override void OnModelCreating(ModelBuilder modelBuilder) { base.OnModelCreating(modelBuilder); DatabaseConfiguration.ApplyConfiguration(modelBuilder); }
public SiteXsiDetail() { configuration = new DatabaseConfiguration(); mapper = new Mapper(); }
/// <summary> /// Записать параметры конфигурации /// </summary> protected override void OnConfiguring(DbContextOptionsBuilder builder) => DatabaseConfiguration.ConfigureEnumsMapping();
// private readonly string strGetUsersQuery = @"select first_name FirstName,last_name LastName,user_id UserId from security.user_account"; #endregion public PostgresSqlRepository(IOptions <AppSettingsModel> Appstns) { this.appSettings = Appstns; db = DatabaseConfiguration.Build().UsingConnectionString(appSettings.Value.DefaultConnection).UsingProvider(new PostgreSQLDatabaseProvider()).Create(); db.OpenSharedConnection(); }
public void TransactionShouldSupportCustomDupSorter() { Func<int, int, int> comparison = (l, r) => -Math.Sign(l - r); var txn = _env.BeginTransaction(); var options = new DatabaseConfiguration {Flags = DatabaseOpenFlags.Create | DatabaseOpenFlags.DuplicatesFixed}; Func<byte[], byte[], int> compareWith = (l, r) => comparison(BitConverter.ToInt32(l, 0), BitConverter.ToInt32(r, 0)); options.FindDuplicatesWith(Comparer<byte[]>.Create(new Comparison<byte[]>(compareWith))); var db = txn.OpenDatabase(configuration: options); var valuesUnsorted = new [] { 2, 10, 5, 0 }; var valuesSorted = valuesUnsorted.ToArray(); Array.Sort(valuesSorted, new Comparison<int>(comparison)); using (var c = txn.CreateCursor(db)) c.PutMultiple(BitConverter.GetBytes(123), valuesUnsorted.Select(BitConverter.GetBytes).ToArray()); using (var c = txn.CreateCursor(db)) { int order = 0; while (c.MoveNext()) Assert.Equal(valuesSorted[order++], BitConverter.ToInt32(c.Current.Value, 0)); } }
public ExerciseRepository(DatabaseConfiguration configuration) : base(configuration) { }
private ParameterModel ToModel(DatabaseConfiguration configuration, StoredProcedureParameter parameter) { return new ParameterModel { Scale = GetNumericScale(parameter.DataType), Precision = GetNumericPrecision(parameter.DataType), Size = GetSize(parameter.DataType), IsOutput = parameter.IsOutputParameter, //todo //SqlDataType = p.DataType.SqlDataType, SqlDbType = _typeConverter.ToSqlDbDataType(parameter.DataType), Column = new ColumnModel { DatabaseName = parameter.Name, ClrType = _typeConverter.ToClrType(parameter, configuration.TableTypeNamespaceFromStoredProcedure) } }; }
/// <summary> /// Saves a given <see cref="Configuration"/> set to <paramref name="userConfigFileName"/> /// </summary> /// <param name="userConfigFileName">The file to save the <see cref="Configuration"/> to</param> /// <param name="hostingPort">The hosting port to save</param> /// <param name="databaseConfiguration">The <see cref="DatabaseConfiguration"/> to save</param> /// <param name="newGeneralConfiguration">The <see cref="GeneralConfiguration"/> to save</param> /// <param name="fileLoggingConfiguration">The <see cref="FileLoggingConfiguration"/> to save</param> /// <param name="controlPanelConfiguration">The <see cref="ControlPanelConfiguration"/> to save</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/> for the operation</param> /// <returns>A <see cref="Task"/> representing the running operation</returns> async Task SaveConfiguration(string userConfigFileName, ushort?hostingPort, DatabaseConfiguration databaseConfiguration, GeneralConfiguration newGeneralConfiguration, FileLoggingConfiguration fileLoggingConfiguration, ControlPanelConfiguration controlPanelConfiguration, CancellationToken cancellationToken) { await console.WriteAsync(String.Format(CultureInfo.InvariantCulture, "Configuration complete! Saving to {0}", userConfigFileName), true, cancellationToken).ConfigureAwait(false); var map = new Dictionary <string, object>() { { DatabaseConfiguration.Section, databaseConfiguration }, { GeneralConfiguration.Section, newGeneralConfiguration }, { FileLoggingConfiguration.Section, fileLoggingConfiguration }, { ControlPanelConfiguration.Section, controlPanelConfiguration } }; if (hostingPort.HasValue) { map.Add("Kestrel", new { EndPoints = new { Http = new { Url = String.Format(CultureInfo.InvariantCulture, "http://0.0.0.0:{0}", hostingPort) } } }); } var json = JsonConvert.SerializeObject(map, Formatting.Indented); var configBytes = Encoding.UTF8.GetBytes(json); try { await ioManager.WriteAllBytes(userConfigFileName, configBytes, cancellationToken).ConfigureAwait(false); } catch (OperationCanceledException) { throw; } catch (Exception e) { await console.WriteAsync(e.Message, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("For your convienence, here's the json we tried to write out:", true, cancellationToken).ConfigureAwait(false); await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync(json, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync(null, true, cancellationToken).ConfigureAwait(false); await console.WriteAsync("Press any key to exit...", true, cancellationToken).ConfigureAwait(false); await console.PressAnyKeyAsync(cancellationToken).ConfigureAwait(false); throw new OperationCanceledException(); } await console.WriteAsync("Waiting for configuration changes to reload...", true, cancellationToken).ConfigureAwait(false); // we need to wait for the configuration's file system watcher to read and reload the changes await asyncDelayer.Delay(TimeSpan.FromSeconds(5), cancellationToken).ConfigureAwait(false); }