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); } }
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 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> 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); }
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); }