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