public DeploymentLoadPublisher(Silo silo, GlobalConfiguration config)
: base(Constants.DeploymentLoadPublisherSystemTargetId, silo.SiloAddress)
{
this.silo = silo;
statisticsRefreshTime = config.DeploymentLoadPublisherRefreshTime;
periodicStats = new ConcurrentDictionary<SiloAddress, SiloRuntimeStatistics>();
siloStatisticsChangeListeners = new List<ISiloStatisticsChangeListener>();
}
private DeploymentLoadPublisher(Silo silo, TimeSpan freshnessTime)
: base(Constants.DeploymentLoadPublisherSystemTargetId, silo.SiloAddress)
{
this.silo = silo;
statisticsRefreshTime = freshnessTime;
periodicStats = new ConcurrentDictionary<SiloAddress, SiloRuntimeStatistics>();
siloStatisticsChangeListeners = new List<ISiloStatisticsChangeListener>();
}
public StreamProviderManagerAgent(Silo silo, List<IProvider> allSiloProviders)
: base(Constants.StreamProviderManagerAgentSystemTargetId, silo.SiloAddress)
{
logger = LogManager.GetLogger("StreamProviderUpdateAgent", LoggerType.Runtime);
this.streamProviderManager = (StreamProviderManager)silo.StreamProviderManager;
providerConfigurations = silo.GlobalConfig.ProviderConfigurations;
this.allSiloProviders = allSiloProviders;
nonReentrancyGuarantor = new AsyncSerialExecutor();
}
/// <summary>Creates a new silo in a remote app domain and returns a handle to it.</summary>
public static SiloHandle Create(string siloName, Silo.SiloType type, ClusterConfiguration config, NodeConfiguration nodeConfiguration, Dictionary<string, GeneratedAssembly> additionalAssemblies)
{
AppDomainSetup setup = GetAppDomainSetupInfo();
var appDomain = AppDomain.CreateDomain(siloName, null, setup);
// Load each of the additional assemblies.
AppDomainSiloHost.CodeGeneratorOptimizer optimizer = null;
foreach (var assembly in additionalAssemblies.Where(asm => asm.Value != null))
{
if (optimizer == null)
{
optimizer =
(AppDomainSiloHost.CodeGeneratorOptimizer)
appDomain.CreateInstanceAndUnwrap(
typeof(AppDomainSiloHost.CodeGeneratorOptimizer).Assembly.FullName, typeof(AppDomainSiloHost.CodeGeneratorOptimizer).FullName, false,
BindingFlags.Default,
null,
null,
CultureInfo.CurrentCulture,
new object[] { });
}
optimizer.AddCachedAssembly(assembly.Key, assembly.Value);
}
var args = new object[] { siloName, type, config };
var siloHost = (AppDomainSiloHost)appDomain.CreateInstanceAndUnwrap(
typeof(AppDomainSiloHost).Assembly.FullName, typeof(AppDomainSiloHost).FullName, false,
BindingFlags.Default, null, args, CultureInfo.CurrentCulture,
new object[] { });
appDomain.UnhandledException += ReportUnobservedException;
appDomain.DoCallBack(RegisterPerfCountersTelemetryConsumer);
siloHost.Start();
var retValue = new AppDomainSiloHandle
{
Name = siloName,
SiloHost = siloHost,
NodeConfiguration = nodeConfiguration,
SiloAddress = siloHost.SiloAddress,
Type = type,
AppDomain = appDomain,
additionalAssemblies = additionalAssemblies,
#if !NETSTANDARD_TODO
AppDomainTestHook = siloHost.AppDomainTestHook,
#endif
};
retValue.ImportGeneratedAssemblies();
return retValue;
}
public SiloControl(
Silo silo,
DeploymentLoadPublisher deploymentLoadPublisher,
Catalog catalog,
GrainTypeManager grainTypeManager,
ISiloPerformanceMetrics siloMetrics)
: base(Constants.SiloControlId, silo.SiloAddress)
{
this.silo = silo;
this.deploymentLoadPublisher = deploymentLoadPublisher;
this.catalog = catalog;
this.grainTypeManager = grainTypeManager;
this.siloMetrics = siloMetrics;
}
internal IReminderService CreateReminderService(Silo silo, IGrainFactory grainFactory, TimeSpan iniTimeSpan, ISiloRuntimeClient runtimeClient)
{
var reminderServiceType = silo.GlobalConfig.ReminderServiceType;
logger.Info("Creating reminder system target for type={0}", Enum.GetName(typeof(GlobalConfiguration.ReminderServiceProviderType), reminderServiceType));
ReminderTable.Initialize(silo, grainFactory, silo.GlobalConfig.ReminderTableAssembly);
return new LocalReminderService(
silo.SiloAddress,
Constants.ReminderServiceId,
silo.RingProvider,
silo.LocalScheduler,
ReminderTable.Singleton,
silo.GlobalConfig,
iniTimeSpan);
}
/// <summary>
/// Initializes a new instance of the <see cref="SiloInitializationParameters"/> class.
/// </summary>
/// <param name="name">The name of this silo.</param>
/// <param name="type">The type of this silo.</param>
/// <param name="config">The cluster configuration.</param>
public SiloInitializationParameters(string name, Silo.SiloType type, ClusterConfiguration config)
{
this.ClusterConfig = config;
this.Type = type;
this.Name = name;
this.ClusterConfig.OnConfigChange(
"Defaults",
() => this.NodeConfig = this.ClusterConfig.GetOrCreateNodeConfigurationForSilo(this.Name));
if (this.NodeConfig.Generation == 0)
{
this.NodeConfig.Generation = SiloAddress.AllocateNewGeneration();
}
this.SiloAddress = SiloAddress.New(this.NodeConfig.Endpoint, this.NodeConfig.Generation);
}
private static Silo LoadSiloInNewAppDomain(string siloName, Silo.SiloType type, ClusterConfiguration config, out AppDomain appDomain)
{
AppDomainSetup setup = GetAppDomainSetupInfo();
appDomain = AppDomain.CreateDomain(siloName, null, setup);
var args = new object[] { siloName, type, config };
var silo = (Silo)appDomain.CreateInstanceFromAndUnwrap(
"OrleansRuntime.dll", typeof(Silo).FullName, false,
BindingFlags.Default, null, args, CultureInfo.CurrentCulture,
new object[] { });
appDomain.UnhandledException += ReportUnobservedException;
return silo;
}
/// <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 SiloControl(Silo silo)
: base(Constants.SiloControlId, silo.SiloAddress)
{
this.silo = silo;
}
private static Silo LoadSiloInNewAppDomain(string siloName, Silo.SiloType type, ClusterConfiguration config, out AppDomain appDomain)
{
AppDomainSetup setup = GetAppDomainSetupInfo();
appDomain = AppDomain.CreateDomain(siloName, null, setup);
// Load each of the additional assemblies.
Silo.TestHookups.CodeGeneratorOptimizer optimizer = null;
foreach (var assembly in additionalAssemblies)
{
if (optimizer == null)
{
optimizer =
(Silo.TestHookups.CodeGeneratorOptimizer)
appDomain.CreateInstanceFromAndUnwrap(
"OrleansRuntime.dll",
typeof(Silo.TestHookups.CodeGeneratorOptimizer).FullName,
false,
BindingFlags.Default,
null,
null,
CultureInfo.CurrentCulture,
new object[] { });
}
if (assembly.Value != null)
{
optimizer.AddCachedAssembly(assembly.Key, assembly.Value);
}
}
var args = new object[] { siloName, type, config };
var silo = (Silo)appDomain.CreateInstanceFromAndUnwrap(
"OrleansRuntime.dll", typeof(Silo).FullName, false,
BindingFlags.Default, null, args, CultureInfo.CurrentCulture,
new object[] { });
appDomain.UnhandledException += ReportUnobservedException;
return silo;
}
private SiloHandle StartOrleansSilo(Silo.SiloType type, TestingSiloOptions options, int instanceCount, AppDomain shared = null)
{
return StartOrleansSilo(this, type, options, instanceCount, shared);
}
public static void CreateDeploymentLoadPublisher(Silo silo, GlobalConfiguration config)
{
Instance = new DeploymentLoadPublisher(silo, config.DeploymentLoadPublisherRefreshTime);
}
/// <summary>Creates and initializes a silo in the current app domain.</summary>
/// <param name="name">Name of this silo.</param>
/// <param name="siloType">Type of this silo.</param>
/// <param name="config">Silo config data to be used for this silo.</param>
public AppDomainSiloHost(string name, Silo.SiloType siloType, ClusterConfiguration config)
{
this.silo = new Silo(name, siloType, config);
}
private SiloHandle StartOrleansSilo(Silo.SiloType type, ClusterConfiguration clusterConfig, NodeConfiguration nodeConfig)
{
return StartOrleansSilo(this, type, clusterConfig, nodeConfig);
}
/// <summary>
/// Start a new silo in the target cluster
/// </summary>
/// <param name="cluster">The TestCluster in which the silo should be deployed</param>
/// <param name="type">The type of the silo to deploy</param>
/// <param name="clusterConfig">The cluster config to use</param>
/// <param name="nodeConfig">The configuration for the silo to deploy</param>
/// <returns>A handle to the silo deployed</returns>
public static SiloHandle StartOrleansSilo(TestCluster cluster, Silo.SiloType type, ClusterConfiguration clusterConfig, NodeConfiguration nodeConfig)
{
if (cluster == null) throw new ArgumentNullException(nameof(cluster));
var siloName = nodeConfig.SiloName;
cluster.WriteLog("Starting a new silo in app domain {0} with config {1}", siloName, clusterConfig.ToString(siloName));
var handle = cluster.LoadSiloInNewAppDomain(siloName, type, clusterConfig, nodeConfig);
return handle;
}
public static SiloHandle StartOrleansSilo(TestCluster cluster, Silo.SiloType type, ClusterConfiguration clusterConfig, NodeConfiguration nodeConfig)
{
if (cluster == null) throw new ArgumentNullException(nameof(cluster));
var siloName = nodeConfig.SiloName;
cluster.WriteLog("Starting a new silo in app domain {0} with config {1}", siloName, clusterConfig.ToString(siloName));
AppDomain appDomain;
Silo silo = cluster.LoadSiloInNewAppDomain(siloName, type, clusterConfig, out appDomain);
silo.Start();
SiloHandle retValue = new SiloHandle
{
Name = siloName,
Silo = silo,
NodeConfiguration = nodeConfig,
Endpoint = silo.SiloAddress.Endpoint,
AppDomain = appDomain,
};
cluster.ImportGeneratedAssemblies(retValue);
return retValue;
}
private SiloHandle LoadSiloInNewAppDomain(string siloName, Silo.SiloType type, ClusterConfiguration config, NodeConfiguration nodeConfiguration)
{
return AppDomainSiloHandle.Create(siloName, type, config, nodeConfiguration, this.additionalAssemblies);
}
// 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 ProviderManagerSystemTarget(Silo currentSilo)
: base(Constants.ProviderManagerSystemTargetId, currentSilo.SiloAddress)
{
}
public static NodeConfiguration AddNodeConfiguration(ClusterConfiguration config, Silo.SiloType siloType, short instanceNumber, int baseSiloPort, int baseGatewayPort)
{
string siloName;
switch (siloType)
{
case Silo.SiloType.Primary:
siloName = Silo.PrimarySiloName;
break;
default:
siloName = $"Secondary_{instanceNumber}";
break;
}
NodeConfiguration nodeConfig = config.GetOrCreateNodeConfigurationForSilo(siloName);
nodeConfig.HostNameOrIPAddress = "loopback";
nodeConfig.Port = baseSiloPort + instanceNumber;
var proxyAddress = nodeConfig.ProxyGatewayEndpoint?.Address ?? config.Defaults.ProxyGatewayEndpoint?.Address;
if (proxyAddress != null)
{
nodeConfig.ProxyGatewayEndpoint = new IPEndPoint(proxyAddress, baseGatewayPort + instanceNumber);
}
config.Overrides[siloName] = nodeConfig;
return nodeConfig;
}
internal TestHookups(Silo s)
{
silo = s;
ExecuteFastKillInProcessExit = true;
}
