protected void Init(int mode = 1)
{
SiloHostConfig = new TestingSiloOptions
{
StartPrimary = true,
ParallelStart = false,
PickNewDeploymentId = true,
StartFreshOrleans = true,
StartSecondary = false,
SiloConfigFile = new FileInfo("OrleansConfigurationForTesting.xml"),
LivenessType = Orleans.Runtime.Configuration.GlobalConfiguration.LivenessProviderType.MembershipTableGrain,
StartClient = true
};
var clientOptions = new TestingClientOptions
{
ProxiedGateway = true,
Gateways = new List<IPEndPoint>(new[]
{
new IPEndPoint(IPAddress.Loopback, TestingSiloHost.ProxyBasePort),
}),
PreferedGatewayIndex = 0
};
ClusterConfig = new ClusterConfiguration();
ClusterConfig.LoadFromFile(new FileInfo("OrleansConfigurationForConsulTesting.xml").FullName);
ClusterConfig.Globals.DataConnectionString = $"host=localhost;datacenter=dc1;mode={mode}";
ClusterConfig.Globals.DataConnectionStringForReminders = $"host=localhost;datacenter=dc1;mode={mode}";
SiloHost = new MyTestingHost(SiloHostConfig, clientOptions);
ConsulMembershipTable = new ConsulSystemStoreProvider();
}
public MyTestingHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions) :
base(siloOptions, clientOptions)
{
this.siloOptions = siloOptions;
this.clientOptions = clientOptions;
}
public override TestingSiloHost CreateSiloHost()
{
var siloOptions = new TestingSiloOptions
{
StartFreshOrleans = true,
StartSecondary = false,
SiloConfigFile = new FileInfo("OrleansConfigurationForStreamingDeactivationUnitTests.xml"),
};
var clientOptions = new TestingClientOptions
{
ClientConfigFile = new FileInfo("ClientConfigurationForStreamTesting.xml")
};
return new TestingSiloHost(siloOptions, clientOptions);
}
private void Init()
{
SiloConfig = new TestingSiloOptions
{
StartPrimary = true,
ParallelStart = true,
PickNewDeploymentId = true,
StartFreshOrleans = true,
StartSecondary = true,
SiloConfigFile = new FileInfo("OrleansConfigurationForConsulTesting.xml"),
LivenessType = Orleans.Runtime.Configuration.GlobalConfiguration.LivenessProviderType.Custom
};
var clientOptions = new TestingClientOptions
{
ProxiedGateway = true,
Gateways = new List<IPEndPoint>(new[]
{
new IPEndPoint(IPAddress.Loopback, TestingSiloHost.ProxyBasePort),
}),
PreferedGatewayIndex = 0
};
SiloHost = new MyTestingHost(SiloConfig, clientOptions);
}
private SiloHandle StartOrleansSilo(Silo.SiloType type, TestingSiloOptions options, int instanceCount, AppDomain shared = null)
{
return StartOrleansSilo(this, type, options, instanceCount, shared);
}
/// <summary>
/// Start the default Primary and Secondary test silos, plus client in-process,
/// using the specified silo config options.
/// </summary>
protected TestingSiloHost(TestingSiloOptions siloOptions)
: this(siloOptions, new TestingClientOptions())
{
}
public void RedeployTestingSiloHost(TestingSiloOptions siloOptions = null, TestingClientOptions clientOptions = null)
{
StopAllSilos();
DeployTestingSiloHost(siloOptions ?? new TestingSiloOptions(), clientOptions ?? new TestingClientOptions());
}
public static void AdjustForTest(ClusterConfiguration config, TestingSiloOptions options)
{
if (options.AdjustConfig != null) {
options.AdjustConfig(config);
}
config.AdjustForTestEnvironment();
}
/// <summary>
/// Start a new silo in the target cluster
/// </summary>
/// <param name="host">The target cluster</param>
/// <param name="type">The type of the silo to deploy</param>
/// <param name="options">The options to use for the silo</param>
/// <param name="instanceCount">The instance count of the silo</param>
/// <param name="shared">The shared AppDomain to use</param>
/// <returns>A handle to the deployed silo</returns>
public static SiloHandle StartOrleansSilo(TestingSiloHost host, Silo.SiloType type, TestingSiloOptions options, int instanceCount, AppDomain shared = null)
{
if (host == null) throw new ArgumentNullException("host");
// Load initial config settings, then apply some overrides below.
ClusterConfiguration config = new ClusterConfiguration();
try
{
if (options.SiloConfigFile == null)
{
config.StandardLoad();
}
else
{
config.LoadFromFile(options.SiloConfigFile.FullName);
}
}
catch (FileNotFoundException)
{
if (options.SiloConfigFile != null
&& !string.Equals(options.SiloConfigFile.Name, TestingSiloOptions.DEFAULT_SILO_CONFIG_FILE, StringComparison.InvariantCultureIgnoreCase))
{
// if the user is not using the defaults, then throw because the file was legitimally not found
throw;
}
config = ClusterConfiguration.LocalhostPrimarySilo();
config.AddMemoryStorageProvider("Default");
config.AddMemoryStorageProvider("MemoryStore");
}
int basePort = options.BasePort < 0 ? BasePort : options.BasePort;
if (config.Globals.SeedNodes.Count > 0 && options.BasePort < 0)
{
config.PrimaryNode = config.Globals.SeedNodes[0];
}
else
{
config.PrimaryNode = new IPEndPoint(IPAddress.Loopback, basePort);
}
config.Globals.SeedNodes.Clear();
config.Globals.SeedNodes.Add(config.PrimaryNode);
if (!String.IsNullOrEmpty(host.DeploymentId))
{
config.Globals.DeploymentId = host.DeploymentId;
}
config.Defaults.PropagateActivityId = options.PropagateActivityId;
if (options.LargeMessageWarningThreshold > 0)
{
config.Defaults.LargeMessageWarningThreshold = options.LargeMessageWarningThreshold;
}
config.Globals.LivenessType = options.LivenessType;
config.Globals.ReminderServiceType = options.ReminderServiceType;
if (!String.IsNullOrEmpty(options.DataConnectionString))
{
config.Globals.DataConnectionString = options.DataConnectionString;
}
host.Globals = config.Globals;
string siloName;
switch (type)
{
case Silo.SiloType.Primary:
siloName = "Primary";
break;
default:
siloName = "Secondary_" + instanceCount.ToString(CultureInfo.InvariantCulture);
break;
}
NodeConfiguration nodeConfig = config.GetOrCreateNodeConfigurationForSilo(siloName);
nodeConfig.HostNameOrIPAddress = "loopback";
nodeConfig.Port = basePort + instanceCount;
nodeConfig.DefaultTraceLevel = config.Defaults.DefaultTraceLevel;
nodeConfig.PropagateActivityId = config.Defaults.PropagateActivityId;
nodeConfig.BulkMessageLimit = config.Defaults.BulkMessageLimit;
int? gatewayport = null;
if (nodeConfig.ProxyGatewayEndpoint != null && nodeConfig.ProxyGatewayEndpoint.Address != null)
{
gatewayport = (options.ProxyBasePort < 0 ? ProxyBasePort : options.ProxyBasePort) + instanceCount;
nodeConfig.ProxyGatewayEndpoint = new IPEndPoint(nodeConfig.ProxyGatewayEndpoint.Address, gatewayport.Value);
}
config.Globals.ExpectedClusterSize = 2;
config.Overrides[siloName] = nodeConfig;
AdjustForTest(config, options);
WriteLog("Starting a new silo in app domain {0} with config {1}", siloName, config.ToString(siloName));
AppDomain appDomain;
Silo silo = host.LoadSiloInNewAppDomain(siloName, type, config, out appDomain);
silo.Start();
SiloHandle retValue = new SiloHandle
{
Name = siloName,
Silo = silo,
Options = options,
Endpoint = silo.SiloAddress.Endpoint,
GatewayPort = gatewayport,
AppDomain = appDomain,
};
host.ImportGeneratedAssemblies(retValue);
return retValue;
}
public UnitTestSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
: base(siloOptions, clientOptions)
{
}
public StreamFilteringTestsBase(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
: base(siloOptions, clientOptions)
{
}
private async Task InitializeAsync(TestingSiloOptions options, TestingClientOptions clientOptions)
{
bool doStartPrimary = false;
bool doStartSecondary = false;
if (options.StartFreshOrleans)
{
// the previous test was !startFresh, so we need to cleanup after it.
StopAllSilosIfRunning();
if (options.StartPrimary)
{
doStartPrimary = true;
}
if (options.StartSecondary)
{
doStartSecondary = true;
}
}
else
{
var runningInstance = Instance;
if (runningInstance != null)
{
this.Primary = runningInstance.Primary;
this.Secondary = runningInstance.Secondary;
this.Globals = runningInstance.Globals;
this.ClientConfig = runningInstance.ClientConfig;
this.DeploymentId = runningInstance.DeploymentId;
this.DeploymentIdPrefix = runningInstance.DeploymentIdPrefix;
this.GrainFactory = runningInstance.GrainFactory;
this.additionalSilos.AddRange(runningInstance.additionalSilos);
foreach (var additionalAssembly in runningInstance.additionalAssemblies)
{
this.additionalAssemblies.Add(additionalAssembly.Key, additionalAssembly.Value);
}
}
if (options.StartPrimary && Primary == null)
{
// first time.
doStartPrimary = true;
}
if (options.StartSecondary && Secondary == null)
{
doStartSecondary = true;
}
}
if (options.PickNewDeploymentId && String.IsNullOrEmpty(DeploymentId))
{
DeploymentId = GetDeploymentId();
}
if (options.ParallelStart)
{
var handles = new List <Task <SiloHandle> >();
if (doStartPrimary)
{
int instanceCount = InstanceCounter++;
handles.Add(Task.Run(() => StartOrleansSilo(Silo.SiloType.Primary, options, instanceCount)));
}
if (doStartSecondary)
{
int instanceCount = InstanceCounter++;
handles.Add(Task.Run(() => StartOrleansSilo(Silo.SiloType.Secondary, options, instanceCount)));
}
await Task.WhenAll(handles.ToArray());
if (doStartPrimary)
{
Primary = await handles[0];
}
if (doStartSecondary)
{
Secondary = await handles[1];
}
}
else
{
if (doStartPrimary)
{
Primary = StartOrleansSilo(Silo.SiloType.Primary, options, InstanceCounter++);
}
if (doStartSecondary)
{
Secondary = StartOrleansSilo(Silo.SiloType.Secondary, options, InstanceCounter++);
}
}
WriteLog("Done initializing cluster");
if (!GrainClient.IsInitialized && options.StartClient)
{
InitializeClient(clientOptions, options.LargeMessageWarningThreshold);
}
}
public void RedeployTestingSiloHost(TestingSiloOptions siloOptions = null, TestingClientOptions clientOptions = null)
{
StopAllSilos();
DeployTestingSiloHost(siloOptions ?? new TestingSiloOptions(), clientOptions ?? new TestingClientOptions());
}
private SiloHandle StartOrleansSilo(Silo.SiloType type, TestingSiloOptions options, int instanceCount, AppDomain shared = null)
{
return(StartOrleansSilo(this, type, options, instanceCount, shared));
}
/// <summary>
/// Start the default Primary and Secondary test silos, plus client in-process,
/// using the specified silo and client config options.
/// </summary>
protected TestingSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
{
DeployTestingSiloHost(siloOptions, clientOptions);
}
protected ReminderTests_Base(TestingSiloOptions siloOptions)
: base(siloOptions)
{
log = TraceLogger.GetLogger(this.GetType().Name, TraceLogger.LoggerType.Application);
}
/// <summary>
/// Start a new silo in the target cluster
/// </summary>
/// <param name="host">The target cluster</param>
/// <param name="type">The type of the silo to deploy</param>
/// <param name="options">The options to use for the silo</param>
/// <param name="instanceCount">The instance count of the silo</param>
/// <param name="shared">The shared AppDomain to use</param>
/// <returns>A handle to the deployed silo</returns>
public static SiloHandle StartOrleansSilo(TestingSiloHost host, Silo.SiloType type, TestingSiloOptions options, int instanceCount, AppDomain shared = null)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
// Load initial config settings, then apply some overrides below.
ClusterConfiguration config = new ClusterConfiguration();
try
{
if (options.SiloConfigFile == null)
{
config.StandardLoad();
}
else
{
config.LoadFromFile(options.SiloConfigFile.FullName);
}
}
catch (FileNotFoundException)
{
if (options.SiloConfigFile != null &&
!string.Equals(options.SiloConfigFile.Name, TestingSiloOptions.DEFAULT_SILO_CONFIG_FILE, StringComparison.InvariantCultureIgnoreCase))
{
// if the user is not using the defaults, then throw because the file was legitimally not found
throw;
}
config = ClusterConfiguration.LocalhostPrimarySilo();
config.AddMemoryStorageProvider("Default");
config.AddMemoryStorageProvider("MemoryStore");
}
int basePort = options.BasePort < 0 ? BasePort : options.BasePort;
if (config.Globals.SeedNodes.Count > 0 && options.BasePort < 0)
{
config.PrimaryNode = config.Globals.SeedNodes[0];
}
else
{
config.PrimaryNode = new IPEndPoint(IPAddress.Loopback, basePort);
}
config.Globals.SeedNodes.Clear();
config.Globals.SeedNodes.Add(config.PrimaryNode);
if (!String.IsNullOrEmpty(host.DeploymentId))
{
config.Globals.DeploymentId = host.DeploymentId;
}
config.Defaults.PropagateActivityId = options.PropagateActivityId;
if (options.LargeMessageWarningThreshold > 0)
{
config.Defaults.LargeMessageWarningThreshold = options.LargeMessageWarningThreshold;
}
config.Globals.LivenessType = options.LivenessType;
config.Globals.ReminderServiceType = options.ReminderServiceType;
if (!String.IsNullOrEmpty(options.DataConnectionString))
{
config.Globals.DataConnectionString = options.DataConnectionString;
}
host.Globals = config.Globals;
string siloName;
switch (type)
{
case Silo.SiloType.Primary:
siloName = "Primary";
break;
default:
siloName = "Secondary_" + instanceCount.ToString(CultureInfo.InvariantCulture);
break;
}
NodeConfiguration nodeConfig = config.GetOrCreateNodeConfigurationForSilo(siloName);
nodeConfig.HostNameOrIPAddress = "loopback";
nodeConfig.Port = basePort + instanceCount;
nodeConfig.DefaultTraceLevel = config.Defaults.DefaultTraceLevel;
nodeConfig.PropagateActivityId = config.Defaults.PropagateActivityId;
nodeConfig.BulkMessageLimit = config.Defaults.BulkMessageLimit;
int?gatewayport = null;
if (nodeConfig.ProxyGatewayEndpoint != null && nodeConfig.ProxyGatewayEndpoint.Address != null)
{
gatewayport = (options.ProxyBasePort < 0 ? ProxyBasePort : options.ProxyBasePort) + instanceCount;
nodeConfig.ProxyGatewayEndpoint = new IPEndPoint(nodeConfig.ProxyGatewayEndpoint.Address, gatewayport.Value);
}
config.Globals.ExpectedClusterSize = 2;
config.Overrides[siloName] = nodeConfig;
AdjustForTest(config, options);
WriteLog("Starting a new silo in app domain {0} with config {1}", siloName, config.ToString(siloName));
AppDomain appDomain;
Silo silo = host.LoadSiloInNewAppDomain(siloName, type, config, out appDomain);
silo.Start();
SiloHandle retValue = new SiloHandle
{
Name = siloName,
Silo = silo,
Options = options,
Endpoint = silo.SiloAddress.Endpoint,
GatewayPort = gatewayport,
AppDomain = appDomain,
};
host.ImportGeneratedAssemblies(retValue);
return(retValue);
}
/// <summary>
/// Start the default Primary and Secondary test silos, plus client in-process,
/// using the specified silo config options.
/// </summary>
public TestingSiloHost(TestingSiloOptions siloOptions)
: this(siloOptions, new TestingClientOptions())
{
}
/// <summary>
/// Start the default Primary and Secondary test silos, plus client in-process,
/// using the specified silo and client config options.
/// </summary>
public TestingSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
{
DeployTestingSiloHost(siloOptions, clientOptions);
}
/// <summary>
/// Start the default Primary and Secondary test silos, plus client in-process,
/// using the specified silo config options.
/// </summary>
protected TestingSiloHost(TestingSiloOptions siloOptions)
: this(siloOptions, new TestingClientOptions())
{
}
/// <summary>
/// Start the default Primary and Secondary test silos, plus client in-process,
/// using the specified silo and client config options.
/// </summary>
public TestingSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
{
DeployTestingSiloHost(siloOptions, clientOptions);
}
/// <summary>
/// Start the default Primary and Secondary test silos, plus client in-process,
/// using the specified silo config options.
/// </summary>
public TestingSiloHost(TestingSiloOptions siloOptions)
: this(siloOptions, new TestingClientOptions())
{
}
/// <summary>
/// Start a Secondary silo with a given instanceCounter
/// (allows to set the port number as before or new, depending on the scenario).
/// </summary>
public void StartSecondarySilo(TestingSiloOptions secondarySiloOptions, int instanceCounter)
{
secondarySiloOptions.PickNewDeploymentId = false;
Secondary = StartOrleansSilo(Silo.SiloType.Secondary, secondarySiloOptions, instanceCounter);
}
private async Task InitializeAsync(TestingSiloOptions options, TestingClientOptions clientOptions)
{
bool doStartPrimary = false;
bool doStartSecondary = false;
if (options.StartFreshOrleans)
{
// the previous test was !startFresh, so we need to cleanup after it.
StopAllSilosIfRunning();
if (options.StartPrimary)
{
doStartPrimary = true;
}
if (options.StartSecondary)
{
doStartSecondary = true;
}
}
else
{
var runningInstance = Instance;
if (runningInstance != null)
{
this.Primary = runningInstance.Primary;
this.Secondary = runningInstance.Secondary;
this.Globals = runningInstance.Globals;
this.ClientConfig = runningInstance.ClientConfig;
this.DeploymentId = runningInstance.DeploymentId;
this.DeploymentIdPrefix = runningInstance.DeploymentIdPrefix;
this.GrainFactory = runningInstance.GrainFactory;
this.additionalSilos.AddRange(runningInstance.additionalSilos);
foreach (var additionalAssembly in runningInstance.additionalAssemblies)
{
this.additionalAssemblies.Add(additionalAssembly.Key, additionalAssembly.Value);
}
}
if (options.StartPrimary && Primary == null)
{
// first time.
doStartPrimary = true;
}
if (options.StartSecondary && Secondary == null)
{
doStartSecondary = true;
}
}
if (options.PickNewDeploymentId && String.IsNullOrEmpty(DeploymentId))
{
DeploymentId = GetDeploymentId();
}
if (options.ParallelStart)
{
var handles = new List<Task<SiloHandle>>();
if (doStartPrimary)
{
int instanceCount = InstanceCounter++;
handles.Add(Task.Run(() => StartOrleansSilo(Silo.SiloType.Primary, options, instanceCount)));
}
if (doStartSecondary)
{
int instanceCount = InstanceCounter++;
handles.Add(Task.Run(() => StartOrleansSilo(Silo.SiloType.Secondary, options, instanceCount)));
}
await Task.WhenAll(handles.ToArray());
if (doStartPrimary)
{
Primary = await handles[0];
}
if (doStartSecondary)
{
Secondary = await handles[1];
}
}
else
{
if (doStartPrimary)
{
Primary = StartOrleansSilo(Silo.SiloType.Primary, options, InstanceCounter++);
}
if (doStartSecondary)
{
Secondary = StartOrleansSilo(Silo.SiloType.Secondary, options, InstanceCounter++);
}
}
WriteLog("Done initializing cluster");
if (!GrainClient.IsInitialized && options.StartClient)
{
InitializeClient(clientOptions, options.LargeMessageWarningThreshold);
}
}
private async Task InitializeAsync(TestingSiloOptions options, TestingClientOptions clientOptions)
{
bool doStartPrimary = false;
bool doStartSecondary = false;
if (options.StartFreshOrleans)
{
// the previous test was !startFresh, so we need to cleanup after it.
if (Primary != null || Secondary != null || GrainClient.IsInitialized)
{
StopDefaultSilos();
}
StopAdditionalSilos();
if (options.StartPrimary)
{
doStartPrimary = true;
}
if (options.StartSecondary)
{
doStartSecondary = true;
}
}
else
{
if (options.StartPrimary && Primary == null)
{
// first time.
doStartPrimary = true;
}
if (options.StartSecondary && Secondary == null)
{
doStartSecondary = true;
}
}
if (options.PickNewDeploymentId && String.IsNullOrEmpty(DeploymentId))
{
DeploymentId = GetDeploymentId();
}
if (options.ParallelStart)
{
var handles = new List <Task <SiloHandle> >();
if (doStartPrimary)
{
int instanceCount = InstanceCounter++;
handles.Add(Task.Run(() => StartOrleansSilo(Silo.SiloType.Primary, options, instanceCount)));
}
if (doStartSecondary)
{
int instanceCount = InstanceCounter++;
handles.Add(Task.Run(() => StartOrleansSilo(Silo.SiloType.Secondary, options, instanceCount)));
}
await Task.WhenAll(handles.ToArray());
if (doStartPrimary)
{
Primary = await handles[0];
}
if (doStartSecondary)
{
Secondary = await handles[1];
}
}
else
{
if (doStartPrimary)
{
Primary = StartOrleansSilo(Silo.SiloType.Primary, options, InstanceCounter++);
}
if (doStartSecondary)
{
Secondary = StartOrleansSilo(Silo.SiloType.Secondary, options, InstanceCounter++);
}
}
if (!GrainClient.IsInitialized && options.StartClient)
{
ClientConfiguration clientConfig;
if (clientOptions.ClientConfigFile != null)
{
clientConfig = ClientConfiguration.LoadFromFile(clientOptions.ClientConfigFile.FullName);
}
else
{
clientConfig = ClientConfiguration.StandardLoad();
}
if (clientOptions.ProxiedGateway && clientOptions.Gateways != null)
{
clientConfig.Gateways = clientOptions.Gateways;
if (clientOptions.PreferedGatewayIndex >= 0)
{
clientConfig.PreferedGatewayIndex = clientOptions.PreferedGatewayIndex;
}
}
if (clientOptions.PropagateActivityId)
{
clientConfig.PropagateActivityId = clientOptions.PropagateActivityId;
}
if (!String.IsNullOrEmpty(DeploymentId))
{
clientConfig.DeploymentId = DeploymentId;
}
if (Debugger.IsAttached)
{
// Test is running inside debugger - Make timeout ~= infinite
clientConfig.ResponseTimeout = TimeSpan.FromMilliseconds(1000000);
}
else if (clientOptions.ResponseTimeout > TimeSpan.Zero)
{
clientConfig.ResponseTimeout = clientOptions.ResponseTimeout;
}
if (options.LargeMessageWarningThreshold > 0)
{
clientConfig.LargeMessageWarningThreshold = options.LargeMessageWarningThreshold;
}
AdjustForTest(clientConfig);
GrainClient.Initialize(clientConfig);
GrainFactory = GrainClient.GrainFactory;
}
}
public UnitTestSiloHost(TestingSiloOptions siloOptions)
: base(siloOptions)
{
}
private SiloHandle StartOrleansSilo(Silo.SiloType type, TestingSiloOptions options, int instanceCount, AppDomain shared = null)
{
// Load initial config settings, then apply some overrides below.
ClusterConfiguration config = new ClusterConfiguration();
if (options.SiloConfigFile == null)
{
config.StandardLoad();
}
else
{
config.LoadFromFile(options.SiloConfigFile.FullName);
}
int basePort = options.BasePort < 0 ? BasePort : options.BasePort;
if (config.Globals.SeedNodes.Count > 0 && options.BasePort < 0)
{
config.PrimaryNode = config.Globals.SeedNodes[0];
}
else
{
config.PrimaryNode = new IPEndPoint(IPAddress.Loopback, basePort);
}
config.Globals.SeedNodes.Clear();
config.Globals.SeedNodes.Add(config.PrimaryNode);
if (!String.IsNullOrEmpty(DeploymentId))
{
config.Globals.DeploymentId = DeploymentId;
}
config.Defaults.PropagateActivityId = options.PropagateActivityId;
if (options.LargeMessageWarningThreshold > 0)
{
config.Defaults.LargeMessageWarningThreshold = options.LargeMessageWarningThreshold;
}
config.Globals.LivenessType = options.LivenessType;
config.Globals.ReminderServiceType = options.ReminderServiceType;
if (!String.IsNullOrEmpty(options.DataConnectionString))
{
config.Globals.DataConnectionString = options.DataConnectionString;
}
_livenessStabilizationTime = GetLivenessStabilizationTime(config.Globals);
string siloName;
switch (type)
{
case Silo.SiloType.Primary:
siloName = "Primary";
break;
default:
siloName = "Secondary_" + instanceCount.ToString(CultureInfo.InvariantCulture);
break;
}
NodeConfiguration nodeConfig = config.GetConfigurationForNode(siloName);
nodeConfig.HostNameOrIPAddress = "loopback";
nodeConfig.Port = basePort + instanceCount;
nodeConfig.DefaultTraceLevel = config.Defaults.DefaultTraceLevel;
nodeConfig.PropagateActivityId = config.Defaults.PropagateActivityId;
nodeConfig.BulkMessageLimit = config.Defaults.BulkMessageLimit;
if (nodeConfig.ProxyGatewayEndpoint != null && nodeConfig.ProxyGatewayEndpoint.Address != null)
{
nodeConfig.ProxyGatewayEndpoint = new IPEndPoint(nodeConfig.ProxyGatewayEndpoint.Address, ProxyBasePort + instanceCount);
}
config.Globals.ExpectedClusterSize = 2;
config.Overrides[siloName] = nodeConfig;
AdjustForTest(config);
WriteLog("Starting a new silo in app domain {0} with config {1}", siloName, config.ToString(siloName));
AppDomain appDomain;
Silo silo = LoadSiloInNewAppDomain(siloName, type, config, out appDomain);
silo.Start();
SiloHandle retValue = new SiloHandle
{
Name = siloName,
Silo = silo,
Options = options,
Endpoint = silo.SiloAddress.Endpoint,
AppDomain = appDomain,
};
ImportGeneratedAssemblies(retValue);
return(retValue);
}
private void DeployTestingSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
{
siloInitOptions = siloOptions;
clientInitOptions = clientOptions;
AppDomain.CurrentDomain.UnhandledException += ReportUnobservedException;
try
{
InitializeAsync(siloOptions, clientOptions).Wait();
string startMsg = "----------------------------- STARTING NEW UNIT TEST SILO HOST: " + GetType().FullName + " -------------------------------------";
WriteLog(startMsg);
}
catch (TimeoutException te)
{
throw new TimeoutException("Timeout during test initialization", te);
}
catch (Exception ex)
{
Exception baseExc = ex.GetBaseException();
if (baseExc is TimeoutException)
{
throw new TimeoutException("Timeout during test initialization", ex);
}
// IMPORTANT:
// Do NOT re-throw the original exception here, also not as an internal exception inside AggregateException
// Due to the way MS tests works, if the original exception is an Orleans exception,
// it's assembly might not be loaded yet in this phase of the test.
// As a result, we will get "MSTest: Unit Test Adapter threw exception: Type is not resolved for member XXX"
// and will loose the oroginal exception. This makes debugging tests super hard!
// The root cause has to do with us initializing our tests from Test constructor and not from TestInitialize method.
// More details: http://dobrzanski.net/2010/09/20/mstest-unit-test-adapter-threw-exception-type-is-not-resolved-for-member/
throw new Exception(
string.Format("Exception during test initialization: {0}",
TraceLogger.PrintException(baseExc)));
}
}
public void BeforeEachTest()
{
var siloOptions = new TestingSiloOptions
{
StartFreshOrleans = true,
StartPrimary = true,
StartSecondary = false,
SiloConfigFile = new FileInfo("OrleansConfigurationForConsulTesting.xml"),
LivenessType = GlobalConfiguration.LivenessProviderType.MembershipTableGrain,
ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain,
DataConnectionString = $"index={remindersIndex};Host=localhost"
};
var clientOptions = new TestingClientOptions
{
ProxiedGateway = true,
Gateways = new List<IPEndPoint>(new[]
{
new IPEndPoint(IPAddress.Loopback, TestingSiloHost.ProxyBasePort),
}),
PreferedGatewayIndex = 0
};
deleteTestIndices();
ClusterConfig = new ClusterConfiguration();
ClusterConfig.LoadFromFile(siloOptions.SiloConfigFile.FullName);
TestReminderTable = new ElasticReminderTable();
ClusterConfig.Globals.DataConnectionStringForReminders = $"index={ remindersIndex};Host=localhost";
SiloHost = new MyTestingHost(siloOptions,clientOptions);
}
/// <summary>
/// Start a Secondary silo with a given instanceCounter
/// (allows to set the port number as before or new, depending on the scenario).
/// </summary>
public void StartSecondarySilo(TestingSiloOptions secondarySiloOptions, int instanceCounter)
{
secondarySiloOptions.PickNewDeploymentId = false;
Secondary = StartOrleansSilo(Silo.SiloType.Secondary, secondarySiloOptions, instanceCounter);
}
/// <summary> Modify the cluster configurations to the test environment </summary>
/// <param name="config">The cluster configuration to modify</param>
/// <param name="options">the TestingSiloOptions to modify</param>
public static void AdjustForTest(ClusterConfiguration config, TestingSiloOptions options)
{
if (options.AdjustConfig != null) {
options.AdjustConfig(config);
}
config.AdjustForTestEnvironment(TestClusterOptions.FallbackOptions.DefaultExtendedConfiguration["DataConnectionString"]);
}
private async Task InitializeAsync(TestingSiloOptions options, TestingClientOptions clientOptions)
{
bool doStartPrimary = false;
bool doStartSecondary = false;
if (options.StartFreshOrleans)
{
// the previous test was !startFresh, so we need to cleanup after it.
if (Primary != null || Secondary != null || GrainClient.IsInitialized)
{
StopDefaultSilos();
}
StopAdditionalSilos();
if (options.StartPrimary)
{
doStartPrimary = true;
}
if (options.StartSecondary)
{
doStartSecondary = true;
}
}
else
{
if (options.StartPrimary && Primary == null)
{
// first time.
doStartPrimary = true;
}
if (options.StartSecondary && Secondary == null)
{
doStartSecondary = true;
}
}
if (options.PickNewDeploymentId && String.IsNullOrEmpty(DeploymentId))
{
DeploymentId = GetDeploymentId();
}
if (options.ParallelStart)
{
var handles = new List<Task<SiloHandle>>();
if (doStartPrimary)
{
int instanceCount = InstanceCounter++;
handles.Add(Task.Run(() => StartOrleansSilo(Silo.SiloType.Primary, options, instanceCount)));
}
if (doStartSecondary)
{
int instanceCount = InstanceCounter++;
handles.Add(Task.Run(() => StartOrleansSilo(Silo.SiloType.Secondary, options, instanceCount)));
}
await Task.WhenAll(handles.ToArray());
if (doStartPrimary)
{
Primary = await handles[0];
}
if (doStartSecondary)
{
Secondary = await handles[1];
}
}
else
{
if (doStartPrimary)
{
Primary = StartOrleansSilo(Silo.SiloType.Primary, options, InstanceCounter++);
}
if (doStartSecondary)
{
Secondary = StartOrleansSilo(Silo.SiloType.Secondary, options, InstanceCounter++);
}
}
if (!GrainClient.IsInitialized && options.StartClient)
{
ClientConfiguration clientConfig;
if (clientOptions.ClientConfigFile != null)
{
clientConfig = ClientConfiguration.LoadFromFile(clientOptions.ClientConfigFile.FullName);
}
else
{
clientConfig = ClientConfiguration.StandardLoad();
}
if (clientOptions.ProxiedGateway && clientOptions.Gateways != null)
{
clientConfig.Gateways = clientOptions.Gateways;
if (clientOptions.PreferedGatewayIndex >= 0)
clientConfig.PreferedGatewayIndex = clientOptions.PreferedGatewayIndex;
}
if (clientOptions.PropagateActivityId)
{
clientConfig.PropagateActivityId = clientOptions.PropagateActivityId;
}
if (!String.IsNullOrEmpty(DeploymentId))
{
clientConfig.DeploymentId = DeploymentId;
}
if (Debugger.IsAttached)
{
// Test is running inside debugger - Make timeout ~= infinite
clientConfig.ResponseTimeout = TimeSpan.FromMilliseconds(1000000);
}
else if (clientOptions.ResponseTimeout > TimeSpan.Zero)
{
clientConfig.ResponseTimeout = clientOptions.ResponseTimeout;
}
if (options.LargeMessageWarningThreshold > 0)
{
clientConfig.LargeMessageWarningThreshold = options.LargeMessageWarningThreshold;
}
AdjustForTest(clientConfig, clientOptions);
this.ClientConfig = clientConfig;
GrainClient.Initialize(clientConfig);
GrainFactory = GrainClient.GrainFactory;
}
}
protected LivenessTestsBase(TestingSiloOptions siloOptions)
: base(siloOptions)
{ }
// This is a static version that can be called without a TestingSiloHost object (host = null)
public static SiloHandle StartOrleansSilo(TestingSiloHost host, Silo.SiloType type, TestingSiloOptions options, int instanceCount, AppDomain shared = null)
{
// Load initial config settings, then apply some overrides below.
ClusterConfiguration config = new ClusterConfiguration();
if (options.SiloConfigFile == null)
{
config.StandardLoad();
}
else
{
config.LoadFromFile(options.SiloConfigFile.FullName);
}
int basePort = options.BasePort < 0 ? BasePort : options.BasePort;
if (config.Globals.SeedNodes.Count > 0 && options.BasePort < 0)
{
config.PrimaryNode = config.Globals.SeedNodes[0];
}
else
{
config.PrimaryNode = new IPEndPoint(IPAddress.Loopback, basePort);
}
config.Globals.SeedNodes.Clear();
config.Globals.SeedNodes.Add(config.PrimaryNode);
if (!String.IsNullOrEmpty(DeploymentId))
{
config.Globals.DeploymentId = DeploymentId;
}
config.Defaults.PropagateActivityId = options.PropagateActivityId;
if (options.LargeMessageWarningThreshold > 0)
{
config.Defaults.LargeMessageWarningThreshold = options.LargeMessageWarningThreshold;
}
config.Globals.LivenessType = options.LivenessType;
config.Globals.ReminderServiceType = options.ReminderServiceType;
if (!String.IsNullOrEmpty(options.DataConnectionString))
{
config.Globals.DataConnectionString = options.DataConnectionString;
}
_livenessStabilizationTime = GetLivenessStabilizationTime(config.Globals);
if (host != null)
{
host.Globals = config.Globals;
}
string siloName;
switch (type)
{
case Silo.SiloType.Primary:
siloName = "Primary";
break;
default:
siloName = "Secondary_" + instanceCount.ToString(CultureInfo.InvariantCulture);
break;
}
NodeConfiguration nodeConfig = config.GetConfigurationForNode(siloName);
nodeConfig.HostNameOrIPAddress = "loopback";
nodeConfig.Port = basePort + instanceCount;
nodeConfig.DefaultTraceLevel = config.Defaults.DefaultTraceLevel;
nodeConfig.PropagateActivityId = config.Defaults.PropagateActivityId;
nodeConfig.BulkMessageLimit = config.Defaults.BulkMessageLimit;
if (nodeConfig.ProxyGatewayEndpoint != null && nodeConfig.ProxyGatewayEndpoint.Address != null)
{
int proxyBasePort = options.ProxyBasePort < 0 ? ProxyBasePort : options.ProxyBasePort;
nodeConfig.ProxyGatewayEndpoint = new IPEndPoint(nodeConfig.ProxyGatewayEndpoint.Address, proxyBasePort + instanceCount);
}
config.Globals.ExpectedClusterSize = 2;
config.Overrides[siloName] = nodeConfig;
AdjustForTest(config, options);
WriteLog("Starting a new silo in app domain {0} with config {1}", siloName, config.ToString(siloName));
AppDomain appDomain;
Silo silo = LoadSiloInNewAppDomain(siloName, type, config, out appDomain);
silo.Start();
SiloHandle retValue = new SiloHandle
{
Name = siloName,
Silo = silo,
Options = options,
Endpoint = silo.SiloAddress.Endpoint,
AppDomain = appDomain,
};
ImportGeneratedAssemblies(retValue);
return retValue;
}
public override TestingSiloHost CreateSiloHost()
{
TestUtils.CheckForAzureStorage();
var siloOptions = new TestingSiloOptions
{
StartFreshOrleans = true,
StartPrimary = true,
StartSecondary = true,
DataConnectionString = StorageTestConstants.DataConnectionString,
LivenessType = GlobalConfiguration.LivenessProviderType.ZooKeeper,
ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain
};
return new TestingSiloHost(siloOptions);
}
/// <summary>
/// Start the default Primary and Secondary test silos, plus client in-process,
/// using the specified silo and client config options.
/// </summary>
protected TestingSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
{
DeployTestingSiloHost(siloOptions, clientOptions);
}
public override TestingSiloHost CreateSiloHost()
{
//Console.WriteLine("Initializing relational databases...");
var relationalStorage = RelationalStorageForTesting.SetupInstance(AdoNetInvariants.InvariantNameSqlServer, TestDatabaseName).Result;
var siloOptions = new TestingSiloOptions
{
StartFreshOrleans = true,
StartPrimary = true,
StartSecondary = true,
DataConnectionString = relationalStorage.CurrentConnectionString,
LivenessType = GlobalConfiguration.LivenessProviderType.SqlServer,
ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain
};
//Console.WriteLine("TestContext.DeploymentDirectory={0}", context.DeploymentDirectory);
//Console.WriteLine("TestContext=");
//Console.WriteLine(TestUtils.DumpTestContext(context));
return new TestingSiloHost(siloOptions);
}
protected LivenessTestsBase(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
: base(siloOptions, clientOptions)
{ }
public override TestingSiloHost CreateSiloHost()
{
var siloOptions = new TestingSiloOptions
{
StartFreshOrleans = true,
StartPrimary = true,
StartSecondary = true,
LivenessType = GlobalConfiguration.LivenessProviderType.MembershipTableGrain,
ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain
};
var clientOptions = new TestingClientOptions
{
ProxiedGateway = true,
Gateways = new List<IPEndPoint>(new[]
{
new IPEndPoint(IPAddress.Loopback, TestingSiloHost.ProxyBasePort),
new IPEndPoint(IPAddress.Loopback, TestingSiloHost.ProxyBasePort + 1)
}),
PreferedGatewayIndex = 1
};
return new TestingSiloHost(siloOptions, clientOptions);
}
