protected DataAccessModelConfiguration CreatePostgresConfiguration(string databaseName)
{
var retval = PostgresConfiguration.Create(new PostgresSqlDatabaseContextInfo()
{
DatabaseName = databaseName,
ServerName = "localhost",
UserId = "postgres",
Password = "******",
NativeEnums = false,
Categories = null,
Pooling = true,
MinPoolSize = 10,
MaxPoolSize = 10,
SqlDataTypeProvider = Type.GetType("Shaolinq.Postgres.PostgresSqlDataTypeProvider, Shaolinq.Postgres")
});
retval.AlwaysSubmitDefaultValues = this.alwaysSubmitDefaultValues;
retval.ValueTypesAutoImplicitDefault = this.valueTypesAutoImplicitDefault;
retval.SaveAndReuseGeneratedAssemblies = true;
retval.SqlDatabaseContextInfos[0].SqlDataTypes = new List <Type> {
typeof(SqlFixedDateDataType)
};
return(retval);
}
public PostgresReadModelUnitOfWork(PostgresConfiguration configuration, IPostgresConnectionFactory connectionFactory)
{
Connection = connectionFactory.Create(configuration);
Connection.Open();
userRepository = new PostgresReadModelUserRepository(Connection);
transaction = null;
}
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 CreatePostgresConfiguration(string databaseName)
{
return(PostgresConfiguration.Create(new PostgresSqlDatabaseContextInfo()
{
DatabaseName = databaseName,
ServerName = "localhost",
UserId = "postgres",
Password = "******",
NativeEnums = true,
Categories = null
}));
}
public WikiStore(PostgresConfiguration postgresConfiguration)
{
var connectionStrBuilder = new NpgsqlConnectionStringBuilder
{
Database = postgresConfiguration.Database,
Host = postgresConfiguration.Host,
Port = postgresConfiguration.Port,
Username = postgresConfiguration.Username,
Password = postgresConfiguration.Password
};
m_ConnectionString = connectionStrBuilder.ToString();
}
public void Constructor_SetsEverything_ToEmpty()
{
//Arrange
var config = new PostgresConfiguration();
//Act
//Assert
config.Host.Should().BeEmpty();
config.Port.Should().Be(-1);
config.Username.Should().BeEmpty();
config.Password.Should().BeEmpty();
config.Database.Should().BeEmpty();
}
public void GetConnectionString_ThrowsArgumentException_WhenUsernameIsMissing()
{
//Arrange
var config = new PostgresConfiguration();
config.Host = fixture.Create <string>();
config.Port = fixture.Create <int>();
config.Username = string.Empty;;
config.Password = fixture.Create <string>();
config.Database = fixture.Create <string>();
//Act
Action action = (() => config.GetConnectionString());
//Assert
Assert.Throws <ArgumentException>(action);
}
public void GetConnectionString_IsValid_WhenPortIsMissing()
{
//Arrange
var config = new PostgresConfiguration();
config.Host = fixture.Create <string>();
config.Port = -1;
config.Username = fixture.Create <string>();
config.Password = fixture.Create <string>();
config.Database = fixture.Create <string>();
var expectedConnectionString = $"Host={config.Host};Username={config.Username};" +
$"Password={config.Password};Database={config.Database}";
//Act
var connectionString = config.GetConnectionString();
//Assert
connectionString.Should().Be(expectedConnectionString);
}
public void StressTest()
{
var config = PostgresConfiguration.Create("StressTest", "localhost", "postgres", "postgres");
(config.SqlDatabaseContextInfos[0] as PostgresSqlDatabaseContextInfo).MaxPoolSize = 2;
(config.SqlDatabaseContextInfos[0] as PostgresSqlDatabaseContextInfo).KeepAlive = 0;
var dataModel = DataAccessModel.BuildDataAccessModel <TestDataAccessModel>(config);
dataModel.Create(DatabaseCreationOptions.DeleteExistingDatabase);
Console.WriteLine(dataModel.GetCurrentSqlDatabaseContext().ConnectionString);
using (var scope = new DataAccessScope())
{
var school = dataModel.Schools.Create();
var student = dataModel.Students.Create();
student.School = school;
student.Firstname = "Tum";
student.Lastname = "Nguyen";
for (var i = 0; i < 10000; i++)
{
var s2 = dataModel.Students.Create();
s2.School = school;
s2.Firstname = "Student " + i;
}
scope.Complete();
}
const int numThreads = 10;
var cancellationTokenSource = new CancellationTokenSource();
var resetEvents = new List <WaitHandle>();
for (var i = 0; i < numThreads; i++)
{
var resetEvent = new ManualResetEvent(false);
resetEvents.Add(resetEvent);
var dispatchThread = new Thread(_ =>
{
while (!cancellationTokenSource.Token.IsCancellationRequested)
{
try
{
dataModel.Students.ToList();
}
catch (Exception ex)
{
Console.WriteLine("Test error: {0}", ex);
}
}
resetEvent.Set();
})
{
Name = $"Thread: {i + 1}"
};
dispatchThread.Start();
}
Thread.Sleep(10000);
cancellationTokenSource.Cancel();
WaitHandle.WaitAll(resetEvents.ToArray());
}
public PostgresqlContext(IOptions <PostgresConfiguration> configuration)
{
_configuration = configuration.Value ?? throw new ArgumentNullException(nameof(configuration));
}
public IPostgresConnection Create(PostgresConfiguration configuration)
{
return(new PostgresConnection(
new NpgsqlConnection(configuration.GetConnectionString())
));
}
public void Connect()
{
var configuration = PostgresConfiguration.Create(ConnectionString);
var model = DataAccessModel.BuildDataAccessModel <MldbModel>(configuration);
}
