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();
}
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();
}
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();
}
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 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();
}
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);
}
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);
}
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();
}
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();
}
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;
var adoVariant = GetAdoInvariant();
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();
}
protected MembershipTableTestsBase(LoggerFilterOptions filters)
{
loggerFactory = TestingUtils.CreateDefaultLoggerFactory($"{this.GetType()}.log", filters);
logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.clusterId = "test-" + Guid.NewGuid();
logger.Info("ClusterId={0}", this.clusterId);
this.clusterOptions = Options.Create(new ClusterOptions {
ClusterId = this.clusterId
});
membershipTable = CreateMembershipTable(logger);
membershipTable.InitializeMembershipTable(true).Wait();
this.gatewayOptions = Options.Create(new GatewayOptions());
gatewayListProvider = CreateGatewayListProvider(logger);
gatewayListProvider.InitializeGatewayListProvider().Wait();
}
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;
}
private void DoStart()
{
lock (lockable)
{
if (!SystemStatus.Current.Equals(SystemStatus.Created))
{
throw new InvalidOperationException(String.Format("Calling Silo.Start() on a silo which is not in the Created state. This silo is in the {0} state.", SystemStatus.Current));
}
SystemStatus.Current = SystemStatus.Starting;
}
logger.Info(ErrorCode.SiloStarting, "Silo Start()");
// Hook up to receive notification of process exit / Ctrl-C events
AppDomain.CurrentDomain.ProcessExit += HandleProcessExit;
Console.CancelKeyPress += HandleProcessExit;
ConfigureThreadPoolAndServicePointSettings();
// This has to start first so that the directory system target factory gets loaded before we start the router.
typeManager.Start();
InsideRuntimeClient.Current.Start();
// The order of these 4 is pretty much arbitrary.
scheduler.Start();
messageCenter.Start();
incomingPingAgent.Start();
incomingSystemAgent.Start();
incomingAgent.Start();
LocalGrainDirectory.Start();
// Set up an execution context for this thread so that the target creation steps can use asynch values.
RuntimeContext.InitializeMainThread();
SiloProviderRuntime.Initialize(GlobalConfig, SiloIdentity, grainFactory);
InsideRuntimeClient.Current.CurrentStreamProviderRuntime = SiloProviderRuntime.Instance;
statisticsProviderManager = new StatisticsProviderManager("Statistics", SiloProviderRuntime.Instance);
string statsProviderName = statisticsProviderManager.LoadProvider(GlobalConfig.ProviderConfigurations)
.WaitForResultWithThrow(initTimeout);
if (statsProviderName != null)
{
LocalConfig.StatisticsProviderName = statsProviderName;
}
allSiloProviders.AddRange(statisticsProviderManager.GetProviders());
// can call SetSiloMetricsTableDataManager only after MessageCenter is created (dependency on this.SiloAddress).
siloStatistics.SetSiloStatsTableDataManager(this, nodeConfig).WaitWithThrow(initTimeout);
siloStatistics.SetSiloMetricsTableDataManager(this, nodeConfig).WaitWithThrow(initTimeout);
IMembershipTable membershipTable = membershipFactory.GetMembershipTable(GlobalConfig.LivenessType, GlobalConfig.MembershipTableAssembly);
membershipOracle = membershipFactory.CreateMembershipOracle(this, membershipTable);
// This has to follow the above steps that start the runtime components
CreateSystemTargets();
InjectDependencies();
// Validate the configuration.
GlobalConfig.Application.ValidateConfiguration(logger);
// ensure this runs in the grain context, wait for it to complete
scheduler.QueueTask(CreateSystemGrains, catalog.SchedulingContext)
.WaitWithThrow(initTimeout);
if (logger.IsVerbose)
{
logger.Verbose("System grains created successfully.");
}
// Initialize storage providers once we have a basic silo runtime environment operating
storageProviderManager = new StorageProviderManager(grainFactory);
scheduler.QueueTask(
() => storageProviderManager.LoadStorageProviders(GlobalConfig.ProviderConfigurations),
providerManagerSystemTarget.SchedulingContext)
.WaitWithThrow(initTimeout);
catalog.SetStorageManager(storageProviderManager);
allSiloProviders.AddRange(storageProviderManager.GetProviders());
if (logger.IsVerbose)
{
logger.Verbose("Storage provider manager created successfully.");
}
// Load and init stream providers before silo becomes active
var siloStreamProviderManager = (StreamProviderManager)grainRuntime.StreamProviderManager;
scheduler.QueueTask(
() => siloStreamProviderManager.LoadStreamProviders(this.GlobalConfig.ProviderConfigurations, SiloProviderRuntime.Instance),
providerManagerSystemTarget.SchedulingContext)
.WaitWithThrow(initTimeout);
InsideRuntimeClient.Current.CurrentStreamProviderManager = siloStreamProviderManager;
allSiloProviders.AddRange(siloStreamProviderManager.GetProviders());
if (logger.IsVerbose)
{
logger.Verbose("Stream provider manager created successfully.");
}
ISchedulingContext statusOracleContext = ((SystemTarget)LocalSiloStatusOracle).SchedulingContext;
bool waitForPrimaryToStart = globalConfig.PrimaryNodeIsRequired && siloType != SiloType.Primary;
if (waitForPrimaryToStart) // only in MembershipTableGrain case.
{
scheduler.QueueTask(() => membershipFactory.WaitForTableToInit(membershipTable), statusOracleContext)
.WaitWithThrow(initTimeout);
}
scheduler.QueueTask(() => membershipTable.InitializeMembershipTable(this.GlobalConfig, true, TraceLogger.GetLogger(membershipTable.GetType().Name)), statusOracleContext)
.WaitWithThrow(initTimeout);
scheduler.QueueTask(() => LocalSiloStatusOracle.Start(), statusOracleContext)
.WaitWithThrow(initTimeout);
if (logger.IsVerbose)
{
logger.Verbose("Local silo status oracle created successfully.");
}
scheduler.QueueTask(LocalSiloStatusOracle.BecomeActive, statusOracleContext)
.WaitWithThrow(initTimeout);
if (logger.IsVerbose)
{
logger.Verbose("Local silo status oracle became active successfully.");
}
try
{
siloStatistics.Start(LocalConfig);
if (logger.IsVerbose)
{
logger.Verbose("Silo statistics manager started successfully.");
}
// Finally, initialize the deployment load collector, for grains with load-based placement
scheduler.QueueTask(DeploymentLoadPublisher.Instance.Start, DeploymentLoadPublisher.Instance.SchedulingContext)
.WaitWithThrow(initTimeout);
if (logger.IsVerbose)
{
logger.Verbose("Silo deployment load publisher started successfully.");
}
// Start background timer tick to watch for platform execution stalls, such as when GC kicks in
platformWatchdog = new Watchdog(nodeConfig.StatisticsLogWriteInterval, healthCheckParticipants);
platformWatchdog.Start();
if (logger.IsVerbose)
{
logger.Verbose("Silo platform watchdog started successfully.");
}
if (reminderService != null)
{
// so, we have the view of the membership in the consistentRingProvider. We can start the reminder service
scheduler.QueueTask(reminderService.Start, ((SystemTarget)reminderService).SchedulingContext)
.WaitWithThrow(initTimeout);
if (logger.IsVerbose)
{
logger.Verbose("Reminder service started successfully.");
}
}
// Start stream providers after silo is active (so the pulling agents don't start sending messages before silo is active).
scheduler.QueueTask(siloStreamProviderManager.StartStreamProviders, providerManagerSystemTarget.SchedulingContext)
.WaitWithThrow(initTimeout);
if (logger.IsVerbose)
{
logger.Verbose("Stream providers started successfully.");
}
var bootstrapProviderManager = new BootstrapProviderManager();
scheduler.QueueTask(
() => bootstrapProviderManager.LoadAppBootstrapProviders(GlobalConfig.ProviderConfigurations),
providerManagerSystemTarget.SchedulingContext)
.WaitWithThrow(initTimeout);
BootstrapProviders = bootstrapProviderManager.GetProviders(); // Data hook for testing & diagnotics
allSiloProviders.AddRange(BootstrapProviders);
if (logger.IsVerbose)
{
logger.Verbose("App bootstrap calls done successfully.");
}
// Now that we're active, we can start the gateway
var mc = messageCenter as MessageCenter;
if (mc != null)
{
mc.StartGateway(clientRegistrar);
}
if (logger.IsVerbose)
{
logger.Verbose("Message gateway service started successfully.");
}
scheduler.QueueTask(clientRegistrar.Start, clientRegistrar.SchedulingContext)
.WaitWithThrow(initTimeout);
if (logger.IsVerbose)
{
logger.Verbose("Client registrar service started successfully.");
}
SystemStatus.Current = SystemStatus.Running;
}
catch (Exception exc)
{
SafeExecute(() => logger.Error(ErrorCode.Runtime_Error_100330, String.Format("Error starting silo {0}. Going to FastKill().", SiloAddress), exc));
FastKill(); // if failed after Membership became active, mark itself as dead in Membership abale.
throw;
}
if (logger.IsVerbose)
{
logger.Verbose("Silo.Start complete: System status = {0}", SystemStatus.Current);
}
}
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;
}
