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