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> Constructor </summary> /// <param name="siloName">Name of this silo.</param> /// <param name="configFile">Silo config file that will be used to initialize this silo.</param> public SiloHost(string siloName, FileInfo configFile) : this(siloName) { ConfigFileName = configFile.FullName; var config = new ClusterConfiguration(); config.LoadFromFile(ConfigFileName); SetSiloConfig(config); }
public static void ClassInitialize(TestContext testContext) { hostName = Dns.GetHostName(); logger = TraceLogger.GetLogger("MembershipTablePluginTests", TraceLogger.LoggerType.Application); ClusterConfiguration cfg = new ClusterConfiguration(); cfg.LoadFromFile("OrleansConfigurationForTesting.xml"); TraceLogger.Initialize(cfg.GetConfigurationForNode("Primary")); TraceLogger.AddTraceLevelOverride("AzureTableDataManager", Severity.Verbose3); TraceLogger.AddTraceLevelOverride("OrleansSiloInstanceManager", Severity.Verbose3); TraceLogger.AddTraceLevelOverride("Storage", Severity.Verbose3); }
public void ServerConfig_LogConsumers() { LogManager.UnInitialize(); string filename = "Config_LogConsumers-OrleansConfiguration.xml"; var cfg = new ClusterConfiguration(); cfg.LoadFromFile(filename); Assert.AreEqual(filename, cfg.SourceFile); LogManager.Initialize(cfg.CreateNodeConfigurationForSilo("Primary")); var actualLogConsumers = LogManager.LogConsumers.Select(x => x.GetType()).ToList(); Xunit.Assert.Contains(typeof(DummyLogConsumer), actualLogConsumers); Assert.AreEqual(1, actualLogConsumers.Count); var actualTelemetryConsumers = LogManager.TelemetryConsumers.Select(x => x.GetType()).ToList(); Xunit.Assert.Contains(typeof(TraceTelemetryConsumer), actualTelemetryConsumers); Xunit.Assert.Contains(typeof(ConsoleTelemetryConsumer), actualTelemetryConsumers); Assert.AreEqual(2, actualTelemetryConsumers.Count); }
public void Limits_ServerConfig() { const string filename = "Config_LogConsumers-OrleansConfiguration.xml"; var orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(filename); NodeConfiguration config; bool hasNodeConfig = orleansConfig.TryGetNodeConfigurationForSilo("Primary", out config); Assert.IsTrue(hasNodeConfig, "Node Primary has config"); string limitName; LimitValue limit; //Assert.IsTrue(config.LimitManager.LimitValues.Count >= 3, "Number of LimitValues: " + string.Join(",", config.LimitValues)); for (int i = 1; i <= 3; i++) { limitName = "Limit" + i; limit = config.LimitManager.GetLimit(limitName); Assert.IsNotNull(limit); Assert.AreEqual(limitName, limit.Name, "Limit name " + i); Assert.AreEqual(i, limit.SoftLimitThreshold, "Soft limit " + i); Assert.AreEqual(2 * i, limit.HardLimitThreshold, "Hard limit " + i); } limitName = "NoHardLimit"; limit = config.LimitManager.GetLimit(limitName); Assert.IsNotNull(limit); Assert.AreEqual(limitName, limit.Name, "Limit name " + limitName); Assert.AreEqual(4, limit.SoftLimitThreshold, "Soft limit " + limitName); Assert.AreEqual(0, limit.HardLimitThreshold, "Hard limit " + limitName); }
public void SiloConfig_SqlServer_StatsProvider() { const string filename = "DevTestServerConfiguration.xml"; var config = new ClusterConfiguration(); config.LoadFromFile(filename); output.WriteLine(config); Assert.AreEqual(2, config.Globals.ProviderConfigurations.Count, "Number of Providers Types"); Assert.IsTrue(config.Globals.ProviderConfigurations.Keys.Contains("Statistics"), "Stats Providers"); ProviderCategoryConfiguration statsProviders = config.Globals.ProviderConfigurations["Statistics"]; Assert.AreEqual(1, statsProviders.Providers.Count, "Number of Stats Providers"); Assert.AreEqual("SQL", statsProviders.Providers.Keys.First(), "Stats provider name"); ProviderConfiguration providerConfig = (ProviderConfiguration)statsProviders.Providers["SQL"]; // Note: Use string here instead of typeof(SqlStatisticsPublisher).FullName to prevent cascade load of this type Assert.AreEqual("Orleans.Providers.SqlServer.SqlStatisticsPublisher", providerConfig.Type, "Stats provider class name"); }
private bool ExtractFireAndForgetDeliveryProperty() { ClusterConfiguration orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(SiloConfigFile.FullName); ProviderCategoryConfiguration providerConfigs = orleansConfig.Globals.ProviderConfigurations["Stream"]; IProviderConfiguration provider = providerConfigs.Providers[SingleStreamTestRunner.SMS_STREAM_PROVIDER_NAME]; string fireAndForgetProperty = null; bool fireAndForget = false; if (provider.Properties.TryGetValue(SimpleMessageStreamProvider.FIRE_AND_FORGET_DELIVERY, out fireAndForgetProperty)) { fireAndForget = Boolean.Parse(fireAndForgetProperty); } return fireAndForget; }
public void NodeLogFileName() { string siloName = "MyNode1"; string baseLogFileName = siloName + ".log"; string baseLogFileNamePlusOne = siloName + "-1.log"; string expectedLogFileName = baseLogFileName; string configFileName = "Config_NonTimestampedLogFileNames.xml"; if (File.Exists(baseLogFileName)) File.Delete(baseLogFileName); if (File.Exists(expectedLogFileName)) File.Delete(expectedLogFileName); var config = new ClusterConfiguration(); config.LoadFromFile(configFileName); var n = config.GetConfigurationForNode(siloName); string fname = n.TraceFileName; Console.WriteLine("LogFileName = " + fname); Assert.AreEqual(baseLogFileName, fname); TraceLogger.Initialize(n); Assert.IsTrue(File.Exists(baseLogFileName), "Base name log file exists: " + baseLogFileName); Assert.IsTrue(File.Exists(expectedLogFileName), "Expected name log file exists: " + expectedLogFileName); Assert.IsFalse(File.Exists(baseLogFileNamePlusOne), "Munged log file exists: " + baseLogFileNamePlusOne); }
public void ServerConfig_LoadFrom() { string filename = "Config_LogConsumers-OrleansConfiguration.xml"; var config = new ClusterConfiguration(); config.LoadFromFile(filename); Assert.IsNotNull(config.ToString(), "OrleansConfiguration.ToString"); Assert.AreEqual(filename, Path.GetFileName(config.SourceFile), "OrleansConfiguration.SourceFile"); }
// 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 void Config_StorageProvider_Azure2() { const string filename = "Config_StorageProvider_Azure2.xml"; const int numProviders = 2; var orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(filename); var providerConfigs = orleansConfig.Globals.ProviderConfigurations["Storage"]; Assert.IsNotNull(providerConfigs, "Null provider configs"); Assert.IsNotNull(providerConfigs.Providers, "Null providers"); Assert.AreEqual(numProviders, providerConfigs.Providers.Count, "Num provider configs"); ProviderConfiguration pCfg = (ProviderConfiguration)providerConfigs.Providers.Values.ToList()[0]; Assert.AreEqual("orleanstest1", pCfg.Name, "Provider name #1"); Assert.AreEqual("AzureTable", pCfg.Type, "Provider type #1"); pCfg = (ProviderConfiguration)providerConfigs.Providers.Values.ToList()[1]; Assert.AreEqual("orleanstest2", pCfg.Name, "Provider name #2"); Assert.AreEqual("AzureTable", pCfg.Type, "Provider type #2"); }
public void ServerConfig_FromFile_FileNotFound() { const string filename = "SiloConfig_NotFound.xml"; try { var config = new ClusterConfiguration(); config.LoadFromFile(filename); } catch (AggregateException ae) { throw ae.Flatten().GetBaseException(); } Assert.Fail("Should have got FileNotFoundException"); }
/// <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 void ServerConfig_LogConsumers() { TraceLogger.UnInitialize(); string filename = "Config_LogConsumers-OrleansConfiguration.xml"; var cfg = new ClusterConfiguration(); cfg.LoadFromFile(filename); Assert.AreEqual(filename, cfg.SourceFile); TraceLogger.Initialize(cfg.CreateNodeConfigurationForSilo("Primary")); Assert.AreEqual(1, TraceLogger.LogConsumers.Count, "Number of log consumers: " + string.Join(",", TraceLogger.LogConsumers)); Assert.AreEqual("UnitTests.DummyLogConsumer", TraceLogger.LogConsumers.Last().GetType().FullName, "Log consumer type"); Assert.AreEqual(2, TraceLogger.TelemetryConsumers.Count, "Number of telemetry consumers: " + string.Join(",", TraceLogger.TelemetryConsumers)); Assert.AreEqual(typeof(TraceTelemetryConsumer).FullName, TraceLogger.TelemetryConsumers.First().GetType().FullName, "TelemetryConsumers consumer type #1"); Assert.AreEqual(typeof(ConsoleTelemetryConsumer).FullName, TraceLogger.TelemetryConsumers.Last().GetType().FullName, "TelemetryConsumers consumer type #1"); }
public static TimeSpan GetDefaultPeriod(Logger log) { int period = 10; // Seconds ClusterConfiguration config = new ClusterConfiguration(); config.LoadFromFile("ClientConfigurationForTesting.xml"); if (config.Globals.UseAzureSystemStore) { period = 12; // azure operations take more time ... so we use a larger period } else if (config.Globals.UseSqlSystemStore) { period = 12; // SQL operations are quite fast ... so we use a shorter period } var reminderPeriod = TimeSpan.FromSeconds(period); log.Info("Using reminder period of {0} for ReminderServiceType={1} in ReminderTestGrain", reminderPeriod, config.Globals.ReminderServiceType); return reminderPeriod; }
public void Limits_LimitsManager_ServerConfig() { const string filename = "Config_LogConsumers-OrleansConfiguration.xml"; var orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(filename); NodeConfiguration config = orleansConfig.GetConfigurationForNode("Primary"); string limitName; LimitValue limit; for (int i = 1; i <= 3; i++) { limitName = "Limit" + i; limit = config.LimitManager.GetLimit(limitName); Assert.IsNotNull(limit); Assert.AreEqual(limitName, limit.Name, "Limit name " + i); Assert.AreEqual(i, limit.SoftLimitThreshold, "Soft limit " + i); Assert.AreEqual(2 * i, limit.HardLimitThreshold, "Hard limit " + i); } limitName = "NoHardLimit"; limit = config.LimitManager.GetLimit(limitName); Assert.IsNotNull(limit); Assert.AreEqual(limitName, limit.Name, "Limit name " + limitName); Assert.AreEqual(4, limit.SoftLimitThreshold, "Soft limit " + limitName); Assert.AreEqual(0, limit.HardLimitThreshold, "No Hard limit " + limitName); limitName = "NotPresent"; limit = config.LimitManager.GetLimit(limitName); Assert.IsNotNull(limit); Assert.AreEqual(limitName, limit.Name, "Limit name " + limitName); Assert.AreEqual(0, limit.SoftLimitThreshold, "No Soft limit " + limitName); Assert.AreEqual(0, limit.HardLimitThreshold, "No Hard limit " + limitName); }
public void Limits_ServerConfig_NotSpecified() { const string filename = "Config_LogConsumers-OrleansConfiguration.xml"; var orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(filename); NodeConfiguration config; bool hasNodeConfig = orleansConfig.TryGetNodeConfigurationForSilo("Primary", out config); Assert.IsTrue(hasNodeConfig, "Node Primary has config"); string limitName = "NotPresent"; LimitValue limit = config.LimitManager.GetLimit(limitName); Assert.AreEqual(0, limit.SoftLimitThreshold); Assert.AreEqual(0, limit.HardLimitThreshold); Assert.AreEqual(limitName, limit.Name); }
public void Config_StorageProvider_SomeConfig() { const string filename = "Config_StorageProvider_SomeConfig.xml"; const int numProviders = 2; var orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(filename); var providerConfigs = orleansConfig.Globals.ProviderConfigurations["Storage"]; Assert.IsNotNull(providerConfigs, "Null provider configs"); Assert.IsNotNull(providerConfigs.Providers, "Null providers"); Assert.AreEqual(numProviders, providerConfigs.Providers.Count, "Num provider configs"); for (int i = 0; i < providerConfigs.Providers.Count; i++) { IProviderConfiguration provider = providerConfigs.Providers.Values.ToList()[i]; Assert.AreEqual("config" + i, ((ProviderConfiguration)provider).Name, "Provider name #" + i); Assert.AreEqual(typeof(MockStorageProvider).FullName, ((ProviderConfiguration)provider).Type, "Provider type #" + i); for (int j = 0; j < 2; j++) { int num = 2 * i + j; string key = "Prop" + num; string cfg = provider.Properties[key]; Assert.IsNotNull(cfg, "Null config value " + key); Assert.IsFalse(string.IsNullOrWhiteSpace(cfg), "Blank config value " + key); Assert.AreEqual(num.ToString(CultureInfo.InvariantCulture), cfg, "Config value {0} = {1}", key, cfg); } } }
public void Limits_ServerConfig_NotSpecified_WithDefault() { const string filename = "Config_LogConsumers-OrleansConfiguration.xml"; var orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(filename); NodeConfiguration config; bool hasNodeConfig = orleansConfig.TryGetNodeConfigurationForSilo("Primary", out config); Assert.IsTrue(hasNodeConfig, "Node Primary has config"); string limitName; LimitValue limit; for (int i = 1; i <= 3; i++) { limitName = "NotPresent" + i; limit = config.LimitManager.GetLimit(limitName, i); Assert.IsNotNull(limit); Assert.AreEqual(limitName, limit.Name, "Limit name " + i); Assert.AreEqual(i, limit.SoftLimitThreshold, "Soft limit " + i); Assert.AreEqual(0, limit.HardLimitThreshold, "No Hard limit " + i); } for (int i = 1; i <= 3; i++) { limitName = "NotPresent" + i; limit = config.LimitManager.GetLimit(limitName, i, 2 * i); Assert.IsNotNull(limit); Assert.AreEqual(limitName, limit.Name, "Limit name " + i); Assert.AreEqual(i, limit.SoftLimitThreshold, "Soft limit " + i); Assert.AreEqual(2 * i, limit.HardLimitThreshold, "Hard limit " + i); } }
public void Config_StorageProviders_AzureTable_Default() { const string filename = "Config_StorageProvider_Azure1.xml"; var config = new ClusterConfiguration(); config.LoadFromFile(filename); output.WriteLine(config.Globals.ToString()); Assert.AreEqual(GlobalConfiguration.LivenessProviderType.MembershipTableGrain, config.Globals.LivenessType, "LivenessType"); Assert.AreEqual(GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain, config.Globals.ReminderServiceType, "ReminderServiceType"); }
public void Config_StorageProvider_NoConfig() { const string filename = "Config_StorageProvider_Memory2.xml"; const int numProviders = 2; var orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(filename); var providerConfigs = orleansConfig.Globals.ProviderConfigurations["Storage"]; Assert.IsNotNull(providerConfigs, "Null provider configs"); Assert.IsNotNull(providerConfigs.Providers, "Null providers"); Assert.AreEqual(numProviders, providerConfigs.Providers.Count, "Num provider configs"); for (int i = 0; i < providerConfigs.Providers.Count; i++) { IProviderConfiguration provider = providerConfigs.Providers.Values.ToList()[i]; Assert.AreEqual("test" + i, ((ProviderConfiguration)provider).Name, "Provider name #" + i); Assert.AreEqual(typeof(MockStorageProvider).FullName, ((ProviderConfiguration)provider).Type, "Provider type #" + i); } }
private bool ParseArguments(string[] args) { string deploymentId = null; string configFileName = null; string siloName = Dns.GetHostName(); // Default to machine name int argPos = 1; for (int i = 0; i < args.Length; i++) { string a = args[i]; if (a.StartsWith("-") || a.StartsWith("/")) { switch (a.ToLowerInvariant()) { case "/?": case "/help": case "-?": case "-help": // Query usage help return false; default: Console.WriteLine("Bad command line arguments supplied: " + a); return false; } } else if (a.Contains("=")) { string[] split = a.Split('='); if (String.IsNullOrEmpty(split[1])) { Console.WriteLine("Bad command line arguments supplied: " + a); return false; } switch (split[0].ToLowerInvariant()) { case "deploymentid": deploymentId = split[1]; break; case "deploymentgroup": // TODO: Remove this at some point in future Console.WriteLine("Ignoring deprecated command line argument: " + a); break; default: Console.WriteLine("Bad command line arguments supplied: " + a); return false; } } // unqualified arguments below else if (argPos == 1) { siloName = a; argPos++; } else if (argPos == 2) { configFileName = a; argPos++; } else { // Too many command line arguments Console.WriteLine("Too many command line arguments supplied: " + a); return false; } } ClusterConfiguration config; if (!string.IsNullOrWhiteSpace(configFileName)) { config = new ClusterConfiguration(); config.LoadFromFile(configFileName); } else { config = ClusterConfiguration.LocalhostPrimarySilo(); } siloHost = new SiloHost(siloName, config); if (deploymentId != null) siloHost.DeploymentId = deploymentId; return true; }
public void Config_AdditionalAssemblyPaths_Config() { const string filename = "Config_AdditionalAssemblies.xml"; const int numPaths = 2; var orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(filename); Assert.IsNotNull(orleansConfig.Defaults.AdditionalAssemblyDirectories, "Additional Assembly Dictionary"); Assert.AreEqual(numPaths, orleansConfig.Defaults.AdditionalAssemblyDirectories.Count, "Additional Assembly count"); }
public void Config_Different_Membership_And_Reminders() { const string filename = "Config_Different_Membership_Reminders.xml"; var config = new ClusterConfiguration(); config.LoadFromFile(filename); Assert.IsTrue(config.Globals.MembershipTableAssembly == "MembershipTableDLL"); Assert.IsTrue(config.Globals.ReminderTableAssembly == "RemindersTableDLL"); Assert.IsTrue(config.Globals.AdoInvariant == "AdoInvariantValue"); Assert.IsTrue(config.Globals.AdoInvariantForReminders == "AdoInvariantForReminders"); Assert.IsTrue(config.Globals.DataConnectionString == "MembershipConnectionString"); Assert.IsTrue(config.Globals.DataConnectionStringForReminders == "RemindersConnectionString"); }
public void ServerConfig_FromFile_FileNotFound() { const string filename = "SiloConfig_NotFound.xml"; var config = new ClusterConfiguration(); Xunit.Assert.Throws<FileNotFoundException>(() => config.LoadFromFile(filename)); }
public void SiloConfig_OldAzure() { const string filename = "Config_OldAzure.xml"; LogManager.Initialize(new NodeConfiguration()); var siloConfig = new ClusterConfiguration(); siloConfig.LoadFromFile(filename); Assert.AreEqual(GlobalConfiguration.LivenessProviderType.AzureTable, siloConfig.Globals.LivenessType, "LivenessType"); Assert.AreEqual(GlobalConfiguration.ReminderServiceProviderType.AzureTable, siloConfig.Globals.ReminderServiceType, "ReminderServiceType"); Assert.IsNotNull(siloConfig.Globals.DataConnectionString, "DataConnectionString should not be null"); Assert.IsFalse(string.IsNullOrWhiteSpace(siloConfig.Globals.DataConnectionString), "DataConnectionString should not be blank"); Assert.IsTrue(siloConfig.Globals.UseAzureSystemStore, "Should be using Azure storage"); Assert.IsFalse(siloConfig.Globals.UseSqlSystemStore, "Should not be using SqlServer storage"); }
public void SiloConfig_SqlServer() { const string filename = "DevTestServerConfiguration.xml"; Guid myGuid = Guid.Empty; LogManager.Initialize(new NodeConfiguration()); var orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(filename); output.WriteLine(orleansConfig.Globals); Assert.AreEqual(GlobalConfiguration.LivenessProviderType.SqlServer, orleansConfig.Globals.LivenessType, "LivenessType"); Assert.AreEqual(GlobalConfiguration.ReminderServiceProviderType.SqlServer, orleansConfig.Globals.ReminderServiceType, "ReminderServiceType"); Assert.IsNotNull(orleansConfig.Globals.DataConnectionString, "DataConnectionString should not be null"); Assert.IsFalse(string.IsNullOrWhiteSpace(orleansConfig.Globals.DataConnectionString), "DataConnectionString should not be blank"); Assert.IsFalse(orleansConfig.Globals.UseAzureSystemStore, "Should not be using Azure storage"); Assert.IsTrue(orleansConfig.Globals.UseSqlSystemStore, "Should be using SqlServer storage"); Assert.AreEqual(orleansConfig.Globals.ServiceId, myGuid, "ServiceId"); }
public void NodeLogFileNameAlreadyExists() { string siloName = "MyNode2"; string baseLogFileName = siloName + ".log"; string baseLogFileNamePlusOne = siloName + "-1.log"; string expectedLogFileName = baseLogFileName; string configFileName = "Config_NonTimestampedLogFileNames.xml"; if (File.Exists(baseLogFileName)) File.Delete(baseLogFileName); if (File.Exists(expectedLogFileName)) File.Delete(expectedLogFileName); if (!File.Exists(baseLogFileName)) File.Create(baseLogFileName).Close(); var config = new ClusterConfiguration(); config.LoadFromFile(configFileName); NodeConfiguration n = config.CreateNodeConfigurationForSilo(siloName); string fname = n.TraceFileName; Assert.AreEqual(baseLogFileName, fname); LogManager.Initialize(n); Assert.IsTrue(File.Exists(baseLogFileName), "Base name log file exists: " + baseLogFileName); Assert.IsTrue(File.Exists(expectedLogFileName), "Expected name log file exists: " + expectedLogFileName); Assert.IsFalse(File.Exists(baseLogFileNamePlusOne), "Munged log file exists: " + baseLogFileNamePlusOne); }
public void SiloConfig_Azure_Default() { const string filename = "Config_Azure_Default.xml"; string deploymentId = "SiloConfig_Azure_Default" + TestConstants.random.Next(); string connectionString = StorageTestConstants.DataConnectionString; var initialConfig = new ClusterConfiguration(); initialConfig.LoadFromFile(filename); output.WriteLine(initialConfig.Globals); // Do same code that AzureSilo does for configuring silo host var host = new SiloHost("SiloConfig_Azure_Default", initialConfig); // Use supplied config data + Initializes logger configurations host.SetSiloType(Silo.SiloType.Secondary); ////// Always use Azure table for membership when running silo in Azure host.SetSiloLivenessType(GlobalConfiguration.LivenessProviderType.AzureTable); host.SetReminderServiceType(GlobalConfiguration.ReminderServiceProviderType.AzureTable); host.SetDeploymentId(deploymentId, connectionString); ClusterConfiguration siloConfig = host.Config; Assert.AreEqual(GlobalConfiguration.LivenessProviderType.AzureTable, siloConfig.Globals.LivenessType, "LivenessType"); Assert.AreEqual(GlobalConfiguration.ReminderServiceProviderType.AzureTable, siloConfig.Globals.ReminderServiceType, "ReminderServiceType"); Assert.AreEqual(deploymentId, siloConfig.Globals.DeploymentId, "DeploymentId"); Assert.AreEqual(connectionString, siloConfig.Globals.DataConnectionString, "DataConnectionString"); Assert.IsTrue(siloConfig.Globals.UseAzureSystemStore, "Should be using Azure storage"); Assert.IsFalse(siloConfig.Globals.UseSqlSystemStore, "Should not be using SqlServer storage"); }
public void LogFile_Write_NotExists() { const string siloName = "MyNode4"; const string configFileName = "Config_NonTimestampedLogFileNames.xml"; string logFileName = siloName + ".log"; FileInfo fileInfo = new FileInfo(logFileName); DeleteIfExists(fileInfo); Assert.IsFalse(File.Exists(fileInfo.FullName), "Log file should not exist: " + fileInfo.FullName); long initialSize = 0; var config = new ClusterConfiguration(); config.LoadFromFile(configFileName); NodeConfiguration n = config.CreateNodeConfigurationForSilo(siloName); string fname = n.TraceFileName; Assert.AreEqual(logFileName, fname); LogManager.Initialize(n); Assert.IsTrue(File.Exists(fileInfo.FullName), "Log file exists - before write: " + fileInfo.FullName); Logger myLogger = LogManager.GetLogger("MyLogger", LoggerType.Application); myLogger.Info("Write something"); LogManager.Flush(); fileInfo.Refresh(); // Need to refresh cached view of FileInfo Assert.IsTrue(fileInfo.Exists, "Log file exists - after write: " + fileInfo.FullName); long currentSize = fileInfo.Length; Assert.IsTrue(currentSize > initialSize, "Log file {0} should have been written to: Initial size = {1} Current size = {2}", logFileName, initialSize, currentSize); }