//protected readonly ClientConfiguration clientConfiguration; protected MembershipTableTestsBase(/*ConnectionStringFixture fixture, TestEnvironmentFixture environment, */ LoggerFilterOptions filters) { //this.environment = environment; //loggerFactory = TestingUtils.CreateDefaultLoggerFactory($"{this.GetType()}.log", filters); //logger = loggerFactory.CreateLogger(this.GetType().FullName); this.clusterId = "test-" + Guid.NewGuid(); this.logger?.Info("ClusterId={clusterId}", this.clusterId); //fixture.InitializeConnectionStringAccessor(GetConnectionString); //this.connectionString = fixture.ConnectionString; this.clusterOptions = Options.Create(new ClusterOptions { ClusterId = this.clusterId }); var adoVariant = GetAdoInvariant(); this.membershipTable = CreateMembershipTable(this.logger); this.membershipTable.InitializeMembershipTable(true).WithTimeout(TimeSpan.FromMinutes(10)).Wait(); //this.clientConfiguration = new ClientConfiguration //{ // ClusterId = this.clusterId, // AdoInvariant = adoVariant, // //DataConnectionString = fixture.ConnectionString //}; this.gatewayListProvider = CreateGatewayListProvider(this.logger); this.gatewayListProvider.InitializeGatewayListProvider().WithTimeout(TimeSpan.FromMinutes(3)).Wait(); }
public MembershipTableManager( ILocalSiloDetails localSiloDetails, IOptions <ClusterMembershipOptions> clusterMembershipOptions, IMembershipTable membershipTable, IFatalErrorHandler fatalErrorHandler, IMembershipGossiper gossiper, ILogger <MembershipTableManager> log, IAsyncTimerFactory timerFactory, ISiloLifecycle siloLifecycle) { this.localSiloDetails = localSiloDetails; this.membershipTableProvider = membershipTable; this.fatalErrorHandler = fatalErrorHandler; this.gossiper = gossiper; this.clusterMembershipOptions = clusterMembershipOptions.Value; this.myAddress = this.localSiloDetails.SiloAddress; this.log = log; this.siloLifecycle = siloLifecycle; this.snapshot = new MembershipTableSnapshot( this.CreateLocalSiloEntry(this.CurrentStatus), MembershipVersion.MinValue, ImmutableDictionary <SiloAddress, MembershipEntry> .Empty); this.updates = new AsyncEnumerable <MembershipTableSnapshot>( (previous, proposed) => proposed.Version > previous.Version, this.snapshot) { OnPublished = update => Interlocked.Exchange(ref this.snapshot, update) }; this.membershipUpdateTimer = timerFactory.Create( this.clusterMembershipOptions.TableRefreshTimeout, nameof(PeriodicallyRefreshMembershipTable)); }
protected MembershipTableTestsBase(ITestOutputHelper output, MultiplexerFixture multiplexerFixture, LoggerFilterOptions filters) { logger = new XunitLogger <MembershipTableTestsBase>(output); this.clusterId = "testC-" + Guid.NewGuid(); this.serviceId = "testS-" + Guid.NewGuid(); this.logger?.Info("ClusterId={0}", this.clusterId); this.logger?.Info("ServiceId={0}", this.serviceId); this.clusterOptions = Options.Create(new ClusterOptions { ClusterId = this.clusterId, ServiceId = this.serviceId }); var adoVariant = GetAdoInvariant(); var options = new RedisOptions { ConnectionString = "localhost:6379, allowAdmin=true", Database = 0 }; this.multiplexerFixture = multiplexerFixture; this.multiplexerFixture.Initialize(options); this.membershipTable = CreateMembershipTable(this.loggerFactory); this.membershipTable.InitializeMembershipTable(true).WithTimeout(TimeSpan.FromMinutes(10)).Wait(); this.gatewayListProvider = CreateGatewayListProvider(this.membershipTable, this.loggerFactory); this.gatewayListProvider.InitializeGatewayListProvider().WithTimeout(TimeSpan.FromMinutes(3)).Wait(); }
internal async Task <IMembershipTable> GetMembershipTable() { if (membershipTable != null) { return(membershipTable); } using (await this.initializationLock.LockAsync()) { if (membershipTable != null) { return(membershipTable); } // get membership through DI var result = this.serviceProvider.GetService <IMembershipTable>(); if (result == null) { string errorMessage = "No membership table provider configured with Silo"; this.logger?.LogCritical(errorMessage); throw new NotImplementedException(errorMessage); } await result.InitializeMembershipTable(true); membershipTable = result; } return(membershipTable); }
public async Task MT_UpdateRow_SqlServer() { var membershipType = GlobalConfiguration.LivenessProviderType.SqlServer; IMembershipTable membership = await GetMembershipTable(membershipType); await MembershipTable_UpdateRow(membership); }
protected const string testDatabaseName = "OrleansMembershipTest";//for relational storage protected MembershipTableTestsBase(ConnectionStringFixture fixture, TestEnvironmentFixture environment, LoggerFilterOptions filters) { this.environment = environment; loggerFactory = TestingUtils.CreateDefaultLoggerFactory(new NodeConfiguration().TraceFileName, filters); logger = new LoggerWrapper <MembershipTableTestsBase>(loggerFactory); deploymentId = "test-" + Guid.NewGuid(); logger.Info("DeploymentId={0}", deploymentId); fixture.InitializeConnectionStringAccessor(GetConnectionString); var globalConfiguration = new GlobalConfiguration { DeploymentId = deploymentId, AdoInvariant = GetAdoInvariant(), DataConnectionString = fixture.ConnectionString }; membershipTable = CreateMembershipTable(logger); membershipTable.InitializeMembershipTable(globalConfiguration, true).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); var clientConfiguration = new ClientConfiguration { DeploymentId = globalConfiguration.DeploymentId, AdoInvariant = globalConfiguration.AdoInvariant, DataConnectionString = globalConfiguration.DataConnectionString }; gatewayListProvider = CreateGatewayListProvider(logger); gatewayListProvider.InitializeGatewayListProvider(clientConfiguration).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); }
protected MembershipTableTestsBase(ITestOutputHelper output, MultiplexerFixture multiplexerFixture, LoggerFilterOptions filters) { this.logger = new XunitLogger <MembershipTableTestsBase>(output); this.clusterId = "testC-" + Guid.NewGuid(); this.serviceId = "testS-" + Guid.NewGuid(); this.logger.Info("ClusterId={0}", this.clusterId); this.logger.Info("ServiceId={0}", this.serviceId); this.clusterOptions = Options.Create(new ClusterOptions { ClusterId = this.clusterId, ServiceId = this.serviceId }); var redisHost = Environment.GetEnvironmentVariable("REDIS_HOST") ?? "localhost"; var redisPort = Environment.GetEnvironmentVariable("REDIS_PORT") ?? "6379"; var options = new RedisClusteringOptions { ConnectionString = $"{redisHost}:{redisPort}, allowAdmin=true", Database = 0 }; this.multiplexerFixture = multiplexerFixture; this.multiplexerFixture.Initialize(options); this.membershipTable = CreateMembershipTable(this.loggerFactory); this.membershipTable.InitializeMembershipTable(true).WithTimeout(TimeSpan.FromMinutes(10)).Wait(); this.gatewayListProvider = CreateGatewayListProvider(this.membershipTable, this.loggerFactory); this.gatewayListProvider.InitializeGatewayListProvider().WithTimeout(TimeSpan.FromMinutes(3)).Wait(); }
protected MembershipTableTestsBase(ConnectionStringFixture fixture, TestEnvironmentFixture environment, LoggerFilterOptions filters) { this.environment = environment; loggerFactory = TestingUtils.CreateDefaultLoggerFactory($"{this.GetType()}.log", filters); logger = new LoggerWrapper <MembershipTableTestsBase>(loggerFactory); this.clusterId = "test-" + Guid.NewGuid(); logger.Info("ClusterId={0}", this.clusterId); fixture.InitializeConnectionStringAccessor(GetConnectionString); this.connectionString = fixture.ConnectionString; globalConfiguration = new GlobalConfiguration { ClusterId = this.clusterId, AdoInvariant = GetAdoInvariant(), DataConnectionString = fixture.ConnectionString }; membershipTable = CreateMembershipTable(logger); membershipTable.InitializeMembershipTable(true).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); clientConfiguration = new ClientConfiguration { ClusterId = globalConfiguration.ClusterId, AdoInvariant = globalConfiguration.AdoInvariant, DataConnectionString = globalConfiguration.DataConnectionString }; gatewayListProvider = CreateGatewayListProvider(logger); gatewayListProvider.InitializeGatewayListProvider().WithTimeout(TimeSpan.FromMinutes(1)).Wait(); }
internal IMembershipOracle CreateMembershipOracle(Silo silo, IMembershipTable membershipTable) { var livenessType = silo.GlobalConfig.LivenessType; logger.Info("Creating membership oracle for type={0}", Enum.GetName(typeof(GlobalConfiguration.LivenessProviderType), livenessType)); return(new MembershipOracle(silo, membershipTable)); }
internal static async Task MembershipTable_ReadAll_Insert_ReadAll(IMembershipTable membership) { MembershipTableData data = await membership.ReadAll(); logger.Info("Membership.ReadAll returned VableVersion={0} Data={1}", data.Version, data); Assert.AreEqual(0, data.Members.Count, "Number of records returned - no table version row"); TableVersion newTableVersion = data.Version.Next(); MembershipEntry newEntry = CreateMembershipEntryForTest(); bool ok = await membership.InsertRow(newEntry, newTableVersion); Assert.IsTrue(ok, "InsertRow completed successfully"); data = await membership.ReadAll(); logger.Info("Membership.ReadAll returned VableVersion={0} Data={1}", data.Version, data); Assert.AreEqual(1, data.Members.Count, "Number of records returned - data row only"); Assert.IsNotNull(data.Version.VersionEtag, "New version ETag should not be null"); Assert.AreNotEqual(newTableVersion.VersionEtag, data.Version.VersionEtag, "New VersionEtag differetnfrom last"); Assert.AreEqual(newTableVersion.Version, data.Version.Version, "New table version number"); MembershipEntry MembershipEntry = data.Members[0].Item1; string eTag = data.Members[0].Item2; logger.Info("Membership.ReadAll returned MembershipEntry ETag={0} Entry={1}", eTag, MembershipEntry); Assert.IsNotNull(eTag, "ETag should not be null"); Assert.IsNotNull(MembershipEntry, "MembershipEntry should not be null"); }
protected MembershipTableTestsBase(ConnectionStringFixture fixture, TestEnvironmentFixture environment, LoggerFilterOptions filters) { this.environment = environment; loggerFactory = TestingUtils.CreateDefaultLoggerFactory($"{this.GetType()}.log", filters); logger = loggerFactory.CreateLogger(this.GetType().FullName); this.clusterId = "test-" + Guid.NewGuid(); logger.Info("ClusterId={0}", this.clusterId); fixture.InitializeConnectionStringAccessor(GetConnectionString); this.connectionString = fixture.ConnectionString; this.siloOptions = Options.Create(new SiloOptions { ClusterId = this.clusterId }); this.clientOptions = Options.Create(new ClusterClientOptions { ClusterId = this.clusterId }); var adoVariant = GetAdoInvariant(); membershipTable = CreateMembershipTable(logger); membershipTable.InitializeMembershipTable(true).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); clientConfiguration = new ClientConfiguration { ClusterId = this.clusterId, AdoInvariant = adoVariant, DataConnectionString = fixture.ConnectionString }; this.gatewayOptions = Options.Create(new GatewayOptions()); gatewayListProvider = CreateGatewayListProvider(logger); gatewayListProvider.InitializeGatewayListProvider().WithTimeout(TimeSpan.FromMinutes(1)).Wait(); }
internal static async Task MembershipTable_ReadRow_Insert_Read(IMembershipTable membership) { MembershipTableData data = await membership.ReadAll(); //TableVersion tableVersion = data.Version; logger.Info("Membership.ReadAll returned VableVersion={0} Data={1}", data.Version, data); Assert.AreEqual(0, data.Members.Count, "Number of records returned - no table version row"); TableVersion newTableVersion = data.Version.Next(); MembershipEntry newEntry = CreateMembershipEntryForTest(); bool ok = await membership.InsertRow(newEntry, newTableVersion); Assert.IsTrue(ok, "InsertRow completed successfully"); data = await membership.ReadRow(newEntry.SiloAddress); logger.Info("Membership.ReadRow returned VableVersion={0} Data={1}", data.Version, data); Assert.AreEqual(1, data.Members.Count, "Number of records returned - data row only"); Assert.IsNotNull(data.Version.VersionEtag, "New version ETag should not be null"); Assert.AreNotEqual(newTableVersion.VersionEtag, data.Version.VersionEtag, "New VersionEtag differetnfrom last"); Assert.AreEqual(newTableVersion.Version, data.Version.Version, "New table version number"); MembershipEntry MembershipEntry = data.Members[0].Item1; string eTag = data.Members[0].Item2; logger.Info("Membership.ReadRow returned MembershipEntry ETag={0} Entry={1}", eTag, MembershipEntry); Assert.IsNotNull(eTag, "ETag should not be null"); Assert.IsNotNull(MembershipEntry, "MembershipEntry should not be null"); }
protected const string testDatabaseName = "OrleansMembershipTest";//for relational storage protected MembershipTableTestsBase(ConnectionStringFixture fixture, TestEnvironmentFixture environment) { this.environment = environment; LogManager.Initialize(new NodeConfiguration()); logger = LogManager.GetLogger(GetType().Name, LoggerType.Application); deploymentId = "test-" + Guid.NewGuid(); logger.Info("DeploymentId={0}", deploymentId); fixture.InitializeConnectionStringAccessor(GetConnectionString); var globalConfiguration = new GlobalConfiguration { DeploymentId = deploymentId, AdoInvariant = GetAdoInvariant(), DataConnectionString = fixture.ConnectionString }; membershipTable = CreateMembershipTable(logger); membershipTable.InitializeMembershipTable(globalConfiguration, true, logger).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); var clientConfiguration = new ClientConfiguration { DeploymentId = globalConfiguration.DeploymentId, AdoInvariant = globalConfiguration.AdoInvariant, DataConnectionString = globalConfiguration.DataConnectionString }; gatewayListProvider = CreateGatewayListProvider(logger); gatewayListProvider.InitializeGatewayListProvider(clientConfiguration, logger).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); }
protected const string testDatabaseName = "OrleansMembershipTest";//for relational storage protected MembershipTableTestsBase(ConnectionStringFixture fixture) { TraceLogger.Initialize(new NodeConfiguration()); logger = TraceLogger.GetLogger(GetType().Name, TraceLogger.LoggerType.Application); deploymentId = "test-" + Guid.NewGuid(); logger.Info("DeploymentId={0}", deploymentId); lock (fixture.SyncRoot) { if (fixture.ConnectionString == null) { fixture.ConnectionString = GetConnectionString(); } } var globalConfiguration = new GlobalConfiguration { DeploymentId = deploymentId, AdoInvariant = GetAdoInvariant(), DataConnectionString = fixture.ConnectionString }; membershipTable = CreateMembershipTable(logger); membershipTable.InitializeMembershipTable(globalConfiguration, true, logger).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); var clientConfiguration = new ClientConfiguration { DeploymentId = globalConfiguration.DeploymentId, AdoInvariant = globalConfiguration.AdoInvariant, DataConnectionString = globalConfiguration.DataConnectionString }; gatewayListProvider = CreateGatewayListProvider(logger); gatewayListProvider.InitializeGatewayListProvider(clientConfiguration, logger).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); }
public async Task GatewaySelection_SqlServer() { string testName = Guid.NewGuid().ToString();// TestContext.TestName; Guid serviceId = Guid.NewGuid(); GlobalConfiguration cfg = new GlobalConfiguration { ServiceId = serviceId, DeploymentId = testName, DataConnectionString = TestHelper.TestUtils.GetSqlConnectionString() }; var membership = new SqlMembershipTable(); var logger = LogManager.GetLogger(membership.GetType().Name); await membership.InitializeMembershipTable(cfg, true, logger); IMembershipTable membershipTable = membership; // Pre-populate gateway table with data int count = 1; foreach (Uri gateway in gatewayAddressUris) { output.WriteLine("Adding gataway data for {0}", gateway); SiloAddress siloAddress = gateway.ToSiloAddress(); Assert.IsNotNull(siloAddress, "Unable to get SiloAddress from Uri {0}", gateway); MembershipEntry MembershipEntry = new MembershipEntry { SiloAddress = siloAddress, HostName = gateway.Host, Status = SiloStatus.Active, ProxyPort = gateway.Port, StartTime = DateTime.UtcNow }; var tableVersion = new TableVersion(count, Guid.NewGuid().ToString()); output.WriteLine("Inserting gataway data for {0} with TableVersion={1}", MembershipEntry, tableVersion); bool ok = await membershipTable.InsertRow(MembershipEntry, tableVersion); count++; Assert.IsTrue(ok, "Membership record should have been written OK but were not: {0}", MembershipEntry); output.WriteLine("Successfully inserted Membership row {0}", MembershipEntry); } MembershipTableData data = await membershipTable.ReadAll(); Assert.IsNotNull(data, "MembershipTableData returned"); Assert.AreEqual(gatewayAddressUris.Count, data.Members.Count, "Number of gateway records read"); IGatewayListProvider listProvider = membership; Test_GatewaySelection(listProvider); }
public RedisGatewayListProvider(IMembershipTable table, GatewayOptions options, ILoggerFactory loggerFactory) { GatewayOptions = options; LoggerFactory = loggerFactory; Logger = loggerFactory?.CreateLogger <RedisGatewayListProvider>(); Logger?.LogInformation("In RedisGatewayListProvider constructor"); _table = table as RedisMembershipTable; }
public void TestCleanup() { if (membership != null && SiloInstanceTableTestConstants.DeleteEntriesAfterTest) { membership.DeleteMembershipTableEntries(deploymentId).Wait(); membership = null; } }
public void Dispose() { if (membershipTable != null && SiloInstanceTableTestConstants.DeleteEntriesAfterTest) { membershipTable.DeleteMembershipTableEntries(deploymentId).Wait(); membershipTable = null; } }
public void TestCleanup() { if (membership != null && SiloInstanceTableTestConstants.DeleteEntriesAfterTest) { membership.DeleteMembershipTableEntries(deploymentId).Wait(); membership = null; } logger.Info("Test {0} completed - Outcome = {1}", TestContext.TestName, TestContext.CurrentTestOutcome); }
private async Task <IMembershipTable> GetMembershipTable() { if (membershipTable == null) { var factory = new MembershipFactory(); membershipTable = await factory.GetMembershipTable(Silo.CurrentSilo); } return(membershipTable); }
internal async Task <IMembershipTable> GetMembershipTable() { if (membershipTable != null) { return(membershipTable); } using (await this.initializationLock.LockAsync()) { if (membershipTable != null) { return(membershipTable); } var globalConfig = this.serviceProvider.GetRequiredService <GlobalConfiguration>(); IMembershipTable result; switch (globalConfig.LivenessType) { case LivenessProviderType.MembershipTableGrain: result = await this.GetMembershipTableGrain(); break; case LivenessProviderType.SqlServer: result = AssemblyLoader.LoadAndCreateInstance <IMembershipTable>(Constants.ORLEANS_SQL_UTILS_DLL, this.logger, this.serviceProvider); break; case LivenessProviderType.AzureTable: result = AssemblyLoader.LoadAndCreateInstance <IMembershipTable>(Constants.ORLEANS_AZURE_UTILS_DLL, this.logger, this.serviceProvider); break; case LivenessProviderType.ZooKeeper: result = AssemblyLoader.LoadAndCreateInstance <IMembershipTable>( Constants.ORLEANS_ZOOKEEPER_UTILS_DLL, this.logger, this.serviceProvider); break; case LivenessProviderType.Custom: result = AssemblyLoader.LoadAndCreateInstance <IMembershipTable>( globalConfig.MembershipTableAssembly, this.logger, this.serviceProvider); break; default: throw new NotImplementedException( $"No membership table provider found for {nameof(globalConfig.LivenessType)}={globalConfig.LivenessType}"); } await result.InitializeMembershipTable(globalConfig, true, this.logger.GetLogger(result.GetType().Name)); membershipTable = result; } return(membershipTable); }
internal async Task <IMembershipOracle> CreateMembershipOracle(Silo silo) { var livenessType = silo.GlobalConfig.LivenessType; logger.Info("Creating membership oracle for type={0}", Enum.GetName(typeof(GlobalConfiguration.LivenessProviderType), livenessType)); IMembershipTable membershipTable = await GetMembershipTable(silo); return(membershipTable == null ? null : new MembershipOracle(silo, membershipTable)); }
internal static async Task MembershipTable_ReadAll_EmptyTable(IMembershipTable membership) { var data = await membership.ReadAll(); Assert.IsNotNull(data, "Membership Data not null"); logger.Info("Membership.ReadAll returned VableVersion={0} Data={1}", data.Version, data); Assert.AreEqual(0, data.Members.Count, "Number of records returned - no table version row"); Assert.IsNotNull(data.Version.VersionEtag, "ETag should not be null"); Assert.AreEqual(0, data.Version.Version, "Initial tabel version should be zero"); }
private async Task <IMembershipTable> GetMembershipTable() { if (membershipTable == null) { var factory = new MembershipFactory((IInternalGrainFactory)this.GrainFactory); membershipTable = factory.GetMembershipTable(Silo.CurrentSilo.GlobalConfig); await membershipTable.InitializeMembershipTable(Silo.CurrentSilo.GlobalConfig, false, LogManager.GetLogger(membershipTable.GetType().Name)); } return(membershipTable); }
private async Task <IMembershipTable> GetMembershipTable() { if (membershipTable == null) { var factory = new MembershipFactory(); membershipTable = factory.GetMembershipTable(Silo.CurrentSilo.GlobalConfig.LivenessType, Silo.CurrentSilo.GlobalConfig.MembershipTableAssembly); await membershipTable.InitializeMembershipTable(Silo.CurrentSilo.GlobalConfig, false, TraceLogger.GetLogger(membershipTable.GetType().Name)); } return(membershipTable); }
internal static async Task MembershipTable_InsertRow(IMembershipTable membership) { var membershipEntry = CreateMembershipEntryForTest(); var data = await membership.ReadAll(); Assert.IsNotNull(data, "Membership Data not null"); Assert.AreEqual(0, data.Members.Count, "Should be no data initially: {0}", data); bool ok = await membership.InsertRow(membershipEntry, data.Version.Next()); Assert.IsTrue(ok, "InsertRow OK"); data = await membership.ReadAll(); Assert.AreEqual(1, data.Members.Count, "Should be one row after insert: {0}", data); }
private async Task MembershipTable_InsertRow(IMembershipTable membership) { MembershipEntry MembershipEntry = CreateMembershipEntryForTest(); MembershipTableData MembershipData = await membership.ReadAll(); Assert.IsNotNull(MembershipData, "Membership Data not null"); Assert.AreEqual(0, MembershipData.Members.Count, "Should be no data initially: {0}", MembershipData); bool ok = await membership.InsertRow(MembershipEntry, MembershipData.Version); Assert.IsTrue(ok, "InsertRow OK"); MembershipData = await membership.ReadAll(); Assert.AreEqual(1, MembershipData.Members.Count, "Should be one row after insert: {0}", MembershipData); }
protected MembershipTableTestsBase(ClusterConfiguration clusterConfiguration) { ConstructorInfo loggerGlobalConfiguration = typeof(Logger).GetConstructors (BindingFlags.Instance | BindingFlags.NonPublic)[0]; //logger = (TraceLogger)loggerGlobalConfiguration.Invoke(new object[] { GetType().Name, TraceLogger.LoggerType.Application }); //logger = (TraceLogger)loggerGlobalConfiguration.Invoke(new object[] {}); this.logger = new NoOpTestLogger(); //LogManager.Initialize(new NodeConfiguration()); //logger = LogManager.GetLogger(GetType().Name, TraceLogger.LoggerType.Application); //logger = new TraceLogger(GetType().Name, TraceLogger.LoggerType.Application); // MethodInfo dynMethod = this.GetType().GetMethod("Draw_" + itemType, //BindingFlags.NonPublic | BindingFlags.Instance); // dynMethod.Invoke(this, new object[] { methodParams }); ConstructorInfo ctorGlobalConfiguration = typeof(GlobalConfiguration).GetConstructors (BindingFlags.Instance | BindingFlags.NonPublic)[0]; GlobalConfiguration globalConfiguration = (GlobalConfiguration)ctorGlobalConfiguration.Invoke(new object[] {}); globalConfiguration.DeploymentId = globalConfiguration.DeploymentId; //globalConfiguration.AdoInvariant = GetAdoInvariant(); globalConfiguration.DataConnectionString = clusterConfiguration.Globals.DataConnectionString; deploymentId = clusterConfiguration.Globals.DeploymentId; globalConfiguration.LivenessType = clusterConfiguration.Globals.LivenessType; globalConfiguration.MembershipTableAssembly = clusterConfiguration.Globals.MembershipTableAssembly; globalConfiguration.ReminderServiceType = clusterConfiguration.Globals.ReminderServiceType; globalConfiguration.DeploymentId = clusterConfiguration.Globals.DeploymentId; membershipTable = CreateMembershipTable(logger); membershipTable.InitializeMembershipTable(globalConfiguration, IsTrue, logger).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); var clientConfiguration = new ClientConfiguration { DeploymentId = globalConfiguration.DeploymentId, AdoInvariant = globalConfiguration.AdoInvariant, DataConnectionString = globalConfiguration.DataConnectionString }; gatewayListProvider = CreateGatewayListProvider(logger); gatewayListProvider.InitializeGatewayListProvider(clientConfiguration, logger).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); }
public MembershipTableCleanupAgent( IOptions <ClusterMembershipOptions> clusterMembershipOptions, IMembershipTable membershipTableProvider, ILogger <MembershipTableCleanupAgent> log, IAsyncTimerFactory timerFactory) { this.clusterMembershipOptions = clusterMembershipOptions.Value; this.membershipTableProvider = membershipTableProvider; this.log = log; if (this.clusterMembershipOptions.DefunctSiloCleanupPeriod.HasValue) { this.cleanupDefunctSilosTimer = timerFactory.Create( this.clusterMembershipOptions.DefunctSiloCleanupPeriod.Value, nameof(CleanupDefunctSilos)); } }
internal static async Task MembershipTable_ReadRow_EmptyTable(IMembershipTable membership, SiloAddress siloAddress) { MembershipTableData data = await membership.ReadRow(siloAddress); TableVersion tableVersion = data.Version; logger.Info("Membership.ReadRow returned VableVersion={0} Data={1}", tableVersion, data); Assert.AreEqual(0, data.Members.Count, "Number of records returned - no table version row"); string eTag = tableVersion.VersionEtag; int ver = tableVersion.Version; logger.Info("Membership.ReadRow returned MembershipEntry ETag={0} TableVersion={1}", eTag, tableVersion); Assert.IsNotNull(eTag, "ETag should not be null"); Assert.AreEqual(0, ver, "Initial table version should be zero"); }
internal static async Task MembershipTable_ReadAll(IMembershipTable membership) { var membershipData = await membership.ReadAll(); Assert.IsNotNull(membershipData, "Membership Data not null"); TableVersion tableVersion = membershipData.Version; logger.Info("Membership.ReadAll returned VableVersion={0} Data={1}", tableVersion, membershipData); Assert.AreEqual(0, membershipData.Members.Count, "Number of records returned - no table version row"); string eTag = tableVersion.VersionEtag; int ver = tableVersion.Version; Assert.IsNotNull(eTag, "ETag should not be null"); Assert.AreEqual(0, ver, "Initial tabel version should be zero"); }
protected MembershipTableTestsBase() { var sp = new ServiceCollection().AddLogging(b => b.AddConsole()).BuildServiceProvider(); loggerFactory = sp.GetRequiredService <ILoggerFactory>(); logger = loggerFactory.CreateLogger(this.GetType().FullName); this.clusterId = "test-" + Guid.NewGuid(); logger?.Info("ClusterId={0}", this.clusterId); membershipTable = CreateMembershipTable(logger, accountEndpoint, accountKey); membershipTable.InitializeMembershipTable(true).WithTimeout(TimeSpan.FromMinutes(3)).Wait(); gatewayListProvider = CreateGatewayListProvider(logger, accountEndpoint, accountKey); gatewayListProvider.InitializeGatewayListProvider().WithTimeout(TimeSpan.FromMinutes(3)).Wait(); }
// Only used with MembershipTableGrain to wiat for primary to start. internal async Task WaitForTableToInit(IMembershipTable membershipTable) { var timespan = Debugger.IsAttached ? TimeSpan.FromMinutes(5) : TimeSpan.FromSeconds(5); // This is a quick temporary solution to enable primary node to start fully before secondaries. // Secondary silos waits untill GrainBasedMembershipTable is created. for (int i = 0; i < 100; i++) { bool needToWait = false; try { MembershipTableData table = await membershipTable.ReadAll().WithTimeout(timespan); if (table.Members.Any(tuple => tuple.Item1.IsPrimary)) { logger.Info(ErrorCode.MembershipTableGrainInit1, "-Connected to membership table provider and also found primary silo registered in the table."); return; } logger.Info(ErrorCode.MembershipTableGrainInit2, "-Connected to membership table provider but did not find primary silo registered in the table. Going to try again for a {0}th time.", i); } catch (Exception exc) { var type = exc.GetBaseException().GetType(); if (type == typeof(TimeoutException) || type == typeof(OrleansException)) { logger.Info(ErrorCode.MembershipTableGrainInit3, "-Waiting for membership table provider to initialize. Going to sleep for {0} and re-try to reconnect.", timespan); needToWait = true; } else { logger.Info(ErrorCode.MembershipTableGrainInit4, "-Membership table provider failed to initialize. Giving up."); throw; } } if (needToWait) { await Task.Delay(timespan); } } }
public void TestInitialize() { logger = TraceLogger.GetLogger(GetType().Name, TraceLogger.LoggerType.Application); deploymentId = "test-" + Guid.NewGuid(); logger.Info("DeploymentId={0}", deploymentId); var globalConfiguration = new GlobalConfiguration { DeploymentId = deploymentId, AdoInvariant = GetAdoInvariant(), DataConnectionString = GetConnectionString() }; var mbr = CreateMembershipTable(logger); mbr.InitializeMembershipTable(globalConfiguration, true, logger).WithTimeout(TimeSpan.FromMinutes(1)).Wait(); membershipTable = mbr; }
private async Task Initialize() { deploymentId = "test-" + Guid.NewGuid(); int generation = SiloAddress.AllocateNewGeneration(); siloAddress = SiloAddress.NewLocalAddress(generation); logger.Info("DeploymentId={0} Generation={1}", deploymentId, generation); GlobalConfiguration config = new GlobalConfiguration { DeploymentId = deploymentId, DataConnectionString = StorageTestConstants.GetZooKeeperConnectionString() }; var mbr = AssemblyLoader.LoadAndCreateInstance<IMembershipTable>(Constants.ORLEANS_ZOOKEEPER_UTILS_DLL, logger); await mbr.InitializeMembershipTable(config, true, logger).WithTimeout(timeout); membership = mbr; }
private async Task Initialize() { deploymentId = "test-" + Guid.NewGuid(); int generation = SiloAddress.AllocateNewGeneration(); siloAddress = SiloAddress.NewLocalAddress(generation); logger.Info("DeploymentId={0} Generation={1}", deploymentId, generation); GlobalConfiguration config = new GlobalConfiguration { DeploymentId = deploymentId, DataConnectionString = relationalStorage.ConnectionString }; var mbr = new SqlMembershipTable(); await mbr.InitializeMembershipTable(config, true, logger).WithTimeout(timeout); membership = mbr; }
// Only used with MembershipTableGrain to wait for primary to start. internal async Task WaitForTableToInit(IMembershipTable membershipTable) { var timespan = Debugger.IsAttached ? TimeSpan.FromMinutes(5) : TimeSpan.FromSeconds(5); // This is a quick temporary solution to enable primary node to start fully before secondaries. // Secondary silos waits untill GrainBasedMembershipTable is created. for (int i = 0; i < 100; i++) { bool needToWait = false; try { MembershipTableData table = await membershipTable.ReadAll().WithTimeout(timespan); logger.Info(ErrorCode.MembershipTableGrainInit2, "-Connected to membership table provider."); return; } catch (Exception exc) { var type = exc.GetBaseException().GetType(); if (type == typeof(TimeoutException) || type == typeof(OrleansException)) { logger.Info(ErrorCode.MembershipTableGrainInit3, "-Waiting for membership table provider to initialize. Going to sleep for {0} and re-try to reconnect.", timespan); needToWait = true; } else { logger.Info(ErrorCode.MembershipTableGrainInit4, "-Membership table provider failed to initialize. Giving up."); throw; } } if (needToWait) { await Task.Delay(timespan); } } }
private async Task<IMembershipTable> GetMembershipTable() { if (membershipTable == null) { var factory = new MembershipFactory((IInternalGrainFactory)this.GrainFactory); membershipTable = factory.GetMembershipTable(Silo.CurrentSilo.GlobalConfig); await membershipTable.InitializeMembershipTable(Silo.CurrentSilo.GlobalConfig, false, LogManager.GetLogger(membershipTable.GetType().Name)); } return membershipTable; }
internal IMembershipOracle CreateMembershipOracle(Silo silo, IMembershipTable membershipTable) { var livenessType = silo.GlobalConfig.LivenessType; logger.Info("Creating membership oracle for type={0}", Enum.GetName(typeof(GlobalConfiguration.LivenessProviderType), livenessType)); return new MembershipOracle(silo, membershipTable); }
private async Task MembershipTable_UpdateRow(IMembershipTable membership) { MembershipEntry MembershipEntry = CreateMembershipEntryForTest(); MembershipTableData MembershipData = await membership.ReadAll(); TableVersion tableVer = MembershipData.Version; Assert.AreEqual(0, MembershipData.Members.Count, "Should be no data initially: {0}", MembershipData); logger.Info("Calling InsertRow with Entry = {0} TableVersion = {1}", MembershipEntry, tableVer); bool ok = await membership.InsertRow(MembershipEntry, tableVer); Assert.IsTrue(ok, "InsertRow OK"); MembershipData = await membership.ReadAll(); Assert.AreEqual(1, MembershipData.Members.Count, "Should be one row after insert: {0}", MembershipData); Tuple<MembershipEntry, string> newEntryData = MembershipData.Get(MembershipEntry.SiloAddress); string eTag = newEntryData.Item2; Assert.IsNotNull(eTag, "ETag should not be null"); tableVer = MembershipData.Version; Assert.IsNotNull(tableVer, "TableVersion should not be null"); tableVer = tableVer.Next(); MembershipEntry = CreateMembershipEntryForTest(); MembershipEntry.Status = SiloStatus.Active; logger.Info("Calling UpdateRow with Entry = {0} eTag = {1} New TableVersion={2}", MembershipEntry, eTag, tableVer); ok = await membership.UpdateRow(MembershipEntry, eTag, tableVer); MembershipData = await membership.ReadAll(); Assert.AreEqual(1, MembershipData.Members.Count, "Should be one row after update: {0}", MembershipData); Assert.IsTrue(ok, "UpdateRow OK - Table Data = {0}", MembershipData); }
internal static async Task MembershipTable_UpdateRow(IMembershipTable membership) { MembershipEntry data = CreateMembershipEntryForTest(); MembershipTableData tableData = await membership.ReadAll(); //TableVersion tableVer = tableData.Version; Assert.IsNotNull(tableData.Version, "TableVersion should not be null"); Assert.AreEqual(0, tableData.Version.Version, "TableVersion should be zero"); Assert.AreEqual(0, tableData.Members.Count, "Should be no data initially: {0}", tableData); TableVersion newTableVer = tableData.Version.Next(); logger.Info("Calling InsertRow with Entry = {0} TableVersion = {1}", data, newTableVer); bool ok = await membership.InsertRow(data, newTableVer); Assert.IsTrue(ok, "InsertRow OK"); tableData = await membership.ReadAll(); Assert.IsNotNull(tableData.Version, "TableVersion should not be null"); Assert.AreEqual(1, tableData.Version.Version, "TableVersion should be 1"); Assert.AreEqual(1, tableData.Members.Count, "Should be one row after insert: {0}", tableData); Tuple<MembershipEntry, string> insertedData = tableData.Get(data.SiloAddress); Assert.IsNotNull(insertedData.Item2, "ETag should not be null"); insertedData.Item1.Status = SiloStatus.Active; newTableVer = tableData.Version.Next(); logger.Info("Calling UpdateRow with Entry = {0} eTag = {1} New TableVersion={2}", insertedData.Item1, insertedData.Item2, newTableVer); ok = await membership.UpdateRow(insertedData.Item1, insertedData.Item2, newTableVer); tableData = await membership.ReadAll(); Assert.IsNotNull(tableData.Version, "TableVersion should not be null"); Assert.AreEqual(2, tableData.Version.Version, "TableVersion should be 2"); Assert.AreEqual(1, tableData.Members.Count, "Should be one row after insert: {0}", tableData); Assert.IsTrue(ok, "UpdateRow OK - Table Data = {0}", tableData); }
// Test function methods private async Task MembershipTable_ReadAll(IMembershipTable membership) { MembershipTableData MembershipData = await membership.ReadAll(); Assert.IsNotNull(MembershipData, "Membership Data not null"); }
internal static async Task MembershipTable_ReadRow_Insert_Read(IMembershipTable membership, SiloAddress siloAddress) { MembershipTableData data = await membership.ReadAll(); TableVersion tableVersion = data.Version; logger.Info("Membership.ReadAll returned VableVersion={0} Data={1}", tableVersion, data); Assert.AreEqual(0, data.Members.Count, "Number of records returned - no table version row"); DateTime now = DateTime.UtcNow; MembershipEntry entry = new MembershipEntry { SiloAddress = siloAddress, StartTime = now, Status = SiloStatus.Active, }; TableVersion newTableVersion = tableVersion.Next(); bool ok = await membership.InsertRow(entry, newTableVersion); Assert.IsTrue(ok, "InsertRow completed successfully"); data = await membership.ReadRow(siloAddress); tableVersion = data.Version; logger.Info("Membership.ReadRow returned VableVersion={0} Data={1}", tableVersion, data); Assert.AreEqual(1, data.Members.Count, "Number of records returned - data row only"); Assert.IsNotNull(tableVersion.VersionEtag, "New version ETag should not be null"); Assert.AreNotEqual(newTableVersion.VersionEtag, tableVersion.VersionEtag, "New VersionEtag differetnfrom last"); Assert.AreEqual(newTableVersion.Version, tableVersion.Version, "New table version number"); MembershipEntry MembershipEntry = data.Members[0].Item1; string eTag = data.Members[0].Item2; logger.Info("Membership.ReadRow returned MembershipEntry ETag={0} Entry={1}", eTag, MembershipEntry); Assert.IsNotNull(eTag, "ETag should not be null"); Assert.IsNotNull(MembershipEntry, "MembershipEntry should not be null"); }
private async Task<IMembershipTable> GetMembershipTable() { if (membershipTable == null) { var factory = new MembershipFactory(); membershipTable = factory.GetMembershipTable(Silo.CurrentSilo.GlobalConfig.LivenessType, Silo.CurrentSilo.GlobalConfig.MembershipTableAssembly); await membershipTable.InitializeMembershipTable(Silo.CurrentSilo.GlobalConfig, false, TraceLogger.GetLogger(membershipTable.GetType().Name)); } return membershipTable; }