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();
}
/// <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)
{
siloInitOptions = siloOptions;
clientInitOptions = clientOptions;
AppDomain.CurrentDomain.UnhandledException += ReportUnobservedException;
try
{
Initialize(siloOptions, clientOptions);
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);
}
throw new AggregateException(
string.Format("Exception during test initialization: {0}",
TraceLogger.PrintException(ex)), ex);
}
}
public MyTestingHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions) :
base(siloOptions, clientOptions)
{
this.siloOptions = siloOptions;
this.clientOptions = clientOptions;
}
/// <summary> Modify the ClientConfiguration to the test environment </summary>
/// <param name="config">The client configuration to modify</param>
/// <param name="options">the TestingClientOptions to modify</param>
public static void AdjustForTest(ClientConfiguration config, TestingClientOptions options)
{
if (options.AdjustConfig != null)
{
options.AdjustConfig(config);
}
config.AdjustForTestEnvironment(TestClusterOptions.FallbackOptions.DefaultExtendedConfiguration["DataConnectionString"]);
}
public void AdjustForTest(ClientConfiguration config, TestingClientOptions options)
{
if (options.AdjustConfig != null)
{
options.AdjustConfig(config);
}
config.AdjustForTestEnvironment();
}
private void InitializeClient(TestingClientOptions clientOptions, int largeMessageWarningThreshold)
{
if (!GrainClient.IsInitialized)
{
WriteLog("Initializing Grain Client");
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 (largeMessageWarningThreshold > 0)
{
clientConfig.LargeMessageWarningThreshold = largeMessageWarningThreshold;
}
AdjustForTest(clientConfig, clientOptions);
this.ClientConfig = clientConfig;
GrainClient.Initialize(clientConfig);
GrainFactory = GrainClient.GrainFactory;
}
}
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 DeployTestingSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
{
siloInitOptions = siloOptions;
clientInitOptions = clientOptions;
AppDomain.CurrentDomain.UnhandledException += ReportUnobservedException;
InitializeLogWriter();
try
{
string startMsg = "----------------------------- STARTING NEW UNIT TEST SILO HOST: " + GetType().FullName + " -------------------------------------";
WriteLog(startMsg);
InitializeAsync(siloOptions, clientOptions).Wait();
UninitializeLogWriter();
Instance = this;
}
catch (TimeoutException te)
{
FlushLogToConsole();
throw new TimeoutException("Timeout during test initialization", te);
}
catch (Exception ex)
{
StopAllSilos();
Exception baseExc = ex.GetBaseException();
FlushLogToConsole();
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 original 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}",
LogFormatter.PrintException(baseExc)));
}
}
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 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;
}
}
public static void AdjustForTest(ClientConfiguration config, TestingClientOptions options)
{
if (options.AdjustConfig != null) {
options.AdjustConfig(config);
}
config.AdjustForTestEnvironment();
}
public void RedeployTestingSiloHost(TestingSiloOptions siloOptions = null, TestingClientOptions clientOptions = null)
{
StopAllSilos();
DeployTestingSiloHost(siloOptions ?? new TestingSiloOptions(), clientOptions ?? new TestingClientOptions());
}
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 UnitTestSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
: base(siloOptions, clientOptions)
{
}
/// <summary> Modify the ClientConfiguration to the test environment </summary>
/// <param name="config">The client configuration to modify</param>
/// <param name="options">the TestingClientOptions to modify</param>
public static void AdjustForTest(ClientConfiguration config, TestingClientOptions options)
{
if (options.AdjustConfig != null) {
options.AdjustConfig(config);
}
config.AdjustForTestEnvironment(TestClusterOptions.FallbackOptions.DefaultExtendedConfiguration["DataConnectionString"]);
}
public void RedeployTestingSiloHost(TestingSiloOptions siloOptions = null, TestingClientOptions clientOptions = null)
{
StopAllSilos();
DeployTestingSiloHost(siloOptions ?? new TestingSiloOptions(), clientOptions ?? new TestingClientOptions());
}
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);
}
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);
GrainClient.Initialize(clientConfig);
GrainFactory = GrainClient.GrainFactory;
}
}
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 void InitializeClient(TestingClientOptions clientOptions, int largeMessageWarningThreshold)
{
if (!GrainClient.IsInitialized)
{
WriteLog("Initializing Grain Client");
ClientConfiguration clientConfig;
try
{
if (clientOptions.ClientConfigFile != null)
{
clientConfig = ClientConfiguration.LoadFromFile(clientOptions.ClientConfigFile.FullName);
}
else
{
clientConfig = ClientConfiguration.StandardLoad();
}
}
catch (FileNotFoundException)
{
if (clientOptions.ClientConfigFile != null
&& !string.Equals(clientOptions.ClientConfigFile.Name, TestingClientOptions.DEFAULT_CLIENT_CONFIG_FILE, StringComparison.InvariantCultureIgnoreCase))
{
// if the user is not using the defaults, then throw because the file was legitimally not found
throw;
}
clientConfig = ClientConfiguration.LocalhostSilo();
}
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 (largeMessageWarningThreshold > 0)
{
clientConfig.LargeMessageWarningThreshold = largeMessageWarningThreshold;
}
AdjustForTest(clientConfig, clientOptions);
this.ClientConfig = clientConfig;
GrainClient.Initialize(clientConfig);
GrainFactory = GrainClient.GrainFactory;
}
}
/// <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 and client config options.
/// </summary>
protected TestingSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
{
DeployTestingSiloHost(siloOptions, clientOptions);
}
private void InitializeClient(TestingClientOptions clientOptions, int largeMessageWarningThreshold)
{
if (this.Client == null)
{
WriteLog("Initializing Grain Client");
ClientConfiguration clientConfig;
try
{
if (clientOptions.ClientConfigFile != null)
{
clientConfig = ClientConfiguration.LoadFromFile(clientOptions.ClientConfigFile.FullName);
}
else
{
clientConfig = ClientConfiguration.StandardLoad();
}
}
catch (FileNotFoundException)
{
if (clientOptions.ClientConfigFile != null &&
!string.Equals(clientOptions.ClientConfigFile.Name, TestingClientOptions.DEFAULT_CLIENT_CONFIG_FILE, StringComparison.InvariantCultureIgnoreCase))
{
// if the user is not using the defaults, then throw because the file was legitimally not found
throw;
}
clientConfig = ClientConfiguration.LocalhostSilo();
}
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(this.DeploymentId))
{
clientConfig.DeploymentId = this.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 (largeMessageWarningThreshold > 0)
{
clientConfig.LargeMessageWarningThreshold = largeMessageWarningThreshold;
}
AdjustForTest(clientConfig, clientOptions);
this.ClientConfig = clientConfig;
try
{
this.InternalClient = (IInternalClusterClient) new ClientBuilder().UseConfiguration(clientConfig).Build();
this.InternalClient.Connect().Wait();
}
catch
{
this.InternalClient?.Abort();
this.InternalClient = null;
throw;
}
}
}
/// <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);
}
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.InternalClient = runningInstance.InternalClient;
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 (this.InternalClient == null || !this.InternalClient.IsInitialized && options.StartClient)
{
InitializeClient(clientOptions, options.LargeMessageWarningThreshold);
}
}
/// <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);
}
public StreamFilteringTestsBase(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
: base(siloOptions, clientOptions)
{
}
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);
}
