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