async Task IClientMetricsDataPublisher.Init(ClientConfiguration config, IPAddress address, string clientId)
{
//TODO: Orleans does not yet provide the type of database used (to, e.g., to load dlls), so SQL Server is assumed.
database = RelationalStorageUtilities.CreateGenericStorageInstance(WellKnownRelationalInvariants.SqlServer, config.DataConnectionString);
await InitOrleansQueriesAsync();
}
public async Task InitializeMembershipTable(GlobalConfiguration config, bool tryInitTableVersion, TraceLogger traceLogger)
{
logger = traceLogger;
deploymentId = config.DeploymentId;
if (logger.IsVerbose3)
{
logger.Verbose3("SqlMembershipTable.InitializeMembershipTable called.");
}
database = RelationalStorageUtilities.CreateGenericStorageInstance(config.AdoInvariant, config.DataConnectionString);
//This initializes all of Orleans operational queries from the database using a well known view
//and assumes the database with appropriate defintions exists already.
queryConstants = await database.InitializeOrleansQueriesAsync();
// even if I am not the one who created the table,
// try to insert an initial table version if it is not already there,
// so we always have a first table version row, before this silo starts working.
if (tryInitTableVersion)
{
var wasCreated = await InitTableAsync();
if (wasCreated)
{
logger.Info("Created new table version row.");
}
}
}
public SqlReminderTable(GlobalConfiguration config)
{
serviceId = config.ServiceId.ToString();
deploymentId = config.DeploymentId;
//TODO: Orleans does not yet provide the type of database used (to, e.g., to load dlls), so SQL Server is assumed.
database = RelationalStorageUtilities.CreateGenericStorageInstance(WellKnownRelationalInvariants.SqlServer, config.DataConnectionString);
}
public async Task Init(GlobalConfiguration config, TraceLogger logger)
{
serviceId = config.ServiceId.ToString();
deploymentId = config.DeploymentId;
database = RelationalStorageUtilities.CreateGenericStorageInstance(config.AdoInvariantForReminders,
config.DataConnectionStringForReminders);
queryConstants = await database.InitializeOrleansQueriesAsync();
}
public Task Init(Guid serviceId, string deploymentId, string connectionString)
{
this.serviceId = serviceId.ToString();
this.deploymentId = deploymentId;
database = RelationalStorageUtilities.CreateGenericStorageInstance(WellKnownRelationalInvariants.SqlServer, connectionString);
return(TaskDone.Done);
}
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Name = name;
logger = providerRuntime.GetLogger("SqlStatisticsPublisher");
//TODO: Orleans does not yet provide the type of database used (to, e.g., to load dlls), so SQL Server is assumed.
database = RelationalStorageUtilities.CreateGenericStorageInstance(WellKnownRelationalInvariants.SqlServer, config.Properties["ConnectionString"]);
await InitOrleansQueriesAsync();
}
public Task InitializeGatewayListProvider(ClientConfiguration config, TraceLogger traceLogger)
{
if (logger.IsVerbose3)
{
logger.Verbose3("SqlMembershipTable.InitializeGatewayListProvider called.");
}
deploymentId = config.DeploymentId;
maxStaleness = config.GatewayListRefreshPeriod;
//TODO: Orleans does not yet provide the type of database used (to, e.g., to load dlls), so SQL Server is assumed.
database = RelationalStorageUtilities.CreateGenericStorageInstance(WellKnownRelationalInvariants.SqlServer, config.DataConnectionString);
return(TaskDone.Done);
}
public async Task InitializeGatewayListProvider(ClientConfiguration config, TraceLogger traceLogger)
{
logger = traceLogger;
if (logger.IsVerbose3)
{
logger.Verbose3("SqlMembershipTable.InitializeGatewayListProvider called.");
}
deploymentId = config.DeploymentId;
maxStaleness = config.GatewayListRefreshPeriod;
database = RelationalStorageUtilities.CreateGenericStorageInstance(config.AdoInvariant, config.DataConnectionString);
//This initializes all of Orleans operational queries from the database using a well known view
//and assumes the database with appropriate defintions exists already.
queryConstants = await database.InitializeOrleansQueriesAsync();
}
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Name = name;
logger = providerRuntime.GetLogger("SqlStatisticsPublisher");
string adoInvariant = AdoNetInvariants.InvariantNameSqlServer;
if (config.Properties.ContainsKey("AdoInvariant"))
{
adoInvariant = config.Properties["AdoInvariant"];
}
database = RelationalStorageUtilities.CreateGenericStorageInstance(adoInvariant, config.Properties["ConnectionString"]);
queryConstants = await database.InitializeOrleansQueriesAsync();
}
public static IRelationalStorage Setup(string testDatabaseName)
{
//We need a bag of management queries for this database.
//Currently there is only SQL Server, so this is procedure is "semi-hardcoded".
var queryBag = CreateTestManagementQueries(AdoNetInvariants.InvariantNameSqlServer);
Console.WriteLine("Initializing relational databases...");
var defaultConnectionString = queryBag.GetConstant(AdoNetInvariants.InvariantNameSqlServer, RelationalTestingConstants.DefaultConnectionStringKey);
var storage = RelationalStorage.CreateInstance(AdoNetInvariants.InvariantNameSqlServer, defaultConnectionString);
Console.WriteLine("Dropping and recreating database '{0}' with connectionstring '{1}'", testDatabaseName, storage.ConnectionString);
var existsQuery = queryBag.GetConstant(storage.InvariantName, RelationalTestingConstants.ExistsDatabaseKey);
if (storage.ExistsDatabaseAsync(existsQuery, testDatabaseName).Result)
{
var dropQuery = queryBag.GetConstant(storage.InvariantName, RelationalTestingConstants.DropDatabaseKey);
storage.DropDatabaseAsync(dropQuery, testDatabaseName).Wait();
}
var creationQuery = queryBag.GetConstant(storage.InvariantName, RelationalTestingConstants.CreateDatabaseKey);
storage.CreateDatabaseAsync(creationQuery, testDatabaseName).Wait();
//The old storage instance has the previous connection string, time have a new handle with a new connection string...
storage = storage.CreateNewStorageInstance(testDatabaseName);
Console.WriteLine("Creating database tables...");
var creationScripts = RelationalStorageUtilities.RemoveBatchSeparators(File.ReadAllText("CreateOrleansTables_SqlServer.sql"));
foreach (var creationScript in creationScripts)
{
var res = storage.ExecuteAsync(creationScript).Result;
}
//Currently there's only one database under test, SQL Server. So this as the other
//setup is hardcoded here: putting the database in simple recovery mode.
//This removes the use of recovery log in case of database crashes, which
//improves performance to some degree, depending on usage. For non-performance testing only.
var simpleModeRes = storage.ExecuteAsync(string.Format("ALTER DATABASE [{0}] SET RECOVERY SIMPLE;", testDatabaseName)).Result;
storage.InitializeOrleansQueriesAsync().Wait();
Console.WriteLine("Initializing relational databases done.");
return(storage);
}
public async Task InitializeGatewayListProvider(ClientConfiguration config, TraceLogger traceLogger)
{
logger = traceLogger;
if (logger.IsVerbose3)
{
logger.Verbose3("SqlMembershipTable.InitializeGatewayListProvider called.");
}
deploymentId = config.DeploymentId;
maxStaleness = config.GatewayListRefreshPeriod;
//TODO: Orleans does not yet provide the type of database used (to, e.g., to load dlls), so SQL Server is assumed.
database = RelationalStorageUtilities.CreateGenericStorageInstance(WellKnownRelationalInvariants.SqlServer, config.DataConnectionString);
//This initializes all of Orleans operational queries from the database using a well known view
//and assumes the database with appropriate defintions exists already.
await InitializeOrleansQueriesAsync();
}
public static void ClassInitialize(TestContext context)
{
Console.WriteLine("TestContext.DeploymentDirectory={0}", context.DeploymentDirectory);
Console.WriteLine("TestContext=");
Console.WriteLine(DumpTestContext(context));
Console.WriteLine("Initializing relational databases...");
relationalStorage = RelationalStorageUtilities.CreateDefaultSqlServerStorageInstance();
Console.WriteLine("Dropping and recreating database '{0}' with connectionstring '{1}'", testDatabaseName, relationalStorage.ConnectionString);
if (relationalStorage.ExistsDatabaseAsync(testDatabaseName).Result)
{
relationalStorage.DropDatabaseAsync(testDatabaseName).Wait();
}
relationalStorage.CreateDatabaseAsync(testDatabaseName).Wait();
//The old storage instance has the previous connection string, time have a new handle with a new connection string...
relationalStorage = relationalStorage.CreateNewStorageInstance(testDatabaseName);
Console.WriteLine("Creating database tables...");
var creationScripts = RelationalStorageUtilities.RemoveBatchSeparators(File.ReadAllText("CreateOrleansTables_SqlServer.sql"));
foreach (var creationScript in creationScripts)
{
var res = relationalStorage.ExecuteAsync(creationScript).Result;
}
//Currently there's only one database under test, SQL Server. So this as the other
//setup is hardcoded here: putting the database in simple recovery mode.
//This removes the use of recovery log in case of database crashes, which
//improves performance to some degree, depending on usage. For non-performance testing only.
var simpleModeRes = relationalStorage.ExecuteAsync(string.Format("ALTER DATABASE [{0}] SET RECOVERY SIMPLE;", testDatabaseName)).Result;
Console.WriteLine("Initializing relational databases done.");
siloOptions.DataConnectionString = relationalStorage.ConnectionString;
}
public static void ClassInitialize(TestContext testContext)
{
TraceLogger.Initialize(new NodeConfiguration());
TraceLogger.AddTraceLevelOverride("SQLMembershipTableTests", Logger.Severity.Verbose3);
// Set shorter init timeout for these tests
OrleansSiloInstanceManager.initTimeout = TimeSpan.FromSeconds(20);
Console.WriteLine("Initializing relational databases...");
relationalStorage = RelationalStorageUtilities.CreateDefaultSqlServerStorageInstance();
Console.WriteLine("Dropping and recreating database '{0}' with connectionstring '{1}'", testDatabaseName, relationalStorage.ConnectionString);
if (relationalStorage.ExistsDatabaseAsync(testDatabaseName).Result)
{
relationalStorage.DropDatabaseAsync(testDatabaseName).Wait();
}
relationalStorage.CreateDatabaseAsync(testDatabaseName).Wait();
//The old storage instance has the previous connection string, time have a new handle with a new connection string...
relationalStorage = relationalStorage.CreateNewStorageInstance(testDatabaseName);
Console.WriteLine("Creating database tables...");
var creationScripts = RelationalStorageUtilities.RemoveBatchSeparators(File.ReadAllText("CreateOrleansTables_SqlServer.sql"));
foreach (var creationScript in creationScripts)
{
var res = relationalStorage.ExecuteAsync(creationScript).Result;
}
//Currently there's only one database under test, SQL Server. So this as the other
//setup is hardcoded here: putting the database in simple recovery mode.
//This removes the use of recovery log in case of database crashes, which
//improves performance to some degree, depending on usage. For non-performance testing only.
var simpleModeRes = relationalStorage.ExecuteAsync(string.Format("ALTER DATABASE [{0}] SET RECOVERY SIMPLE;", testDatabaseName)).Result;
Console.WriteLine("Initializing relational databases done.");
}
async Task IClientMetricsDataPublisher.Init(ClientConfiguration config, IPAddress address, string clientId)
{
database = RelationalStorageUtilities.CreateGenericStorageInstance(config.AdoInvariant, config.DataConnectionString);
queryConstants = await database.InitializeOrleansQueriesAsync();
}
