public WorkerWrapper(IInvokeHandler invokeHandler,
NodeConfiguration nodeConfiguration,
TrySendNodeStartUpNotificationToManagerTimer nodeStartUpNotificationToManagerTimer,
Timer pingToManagerTimer,
TrySendJobDoneStatusToManagerTimer trySendJobDoneStatusToManagerTimer,
TrySendJobCanceledToManagerTimer trySendJobCanceledStatusToManagerTimer,
TrySendJobFaultedToManagerTimer trySendJobFaultedStatusToManagerTimer,
TrySendJobDetailToManagerTimer trySendJobDetailToManagerTimer)
{
_handler = invokeHandler;
_nodeConfiguration = nodeConfiguration;
WhoamI = _nodeConfiguration.CreateWhoIAm(Environment.MachineName);
_nodeStartUpNotificationToManagerTimer = nodeStartUpNotificationToManagerTimer;
_nodeStartUpNotificationToManagerTimer.TrySendNodeStartUpNotificationSucceded +=
NodeStartUpNotificationToManagerTimer_TrySendNodeStartUpNotificationSucceded;
_pingToManagerTimer = pingToManagerTimer;
_trySendJobDoneStatusToManagerTimer = trySendJobDoneStatusToManagerTimer;
_trySendJobCanceledStatusToManagerTimer = trySendJobCanceledStatusToManagerTimer;
_trySendJobFaultedStatusToManagerTimer = trySendJobFaultedStatusToManagerTimer;
_trySendJobDetailToManagerTimer = trySendJobDetailToManagerTimer;
isWorking = false;
_trySendJobDetailToManagerTimer.Start();
_nodeStartUpNotificationToManagerTimer.Start();
}
/// <summary>
/// Configures the specified property info.
/// </summary>
/// <param name="propertyInfo">The property info.</param>
/// <param name="config">The config.</param>
public void Configure(PropertyInfo propertyInfo, NodeConfiguration config)
{
config.Id = this.Id;
config.IsLazy = this.IsLazy;
config.Path = this.Path;
base.Configure(propertyInfo, config);
}
public void OnStartup(NodeConfiguration configuration)
{
configuration.DataAccess.Default
.OnNative(db =>
{
db.EnsureUniqueIndexFor<User>(u => u.Name);
db.EnsureUniqueIndexFor<Post>(u => u.Created);
});
}
public TrySendJobCanceledToManagerTimer(NodeConfiguration nodeConfiguration,
TrySendJobDetailToManagerTimer sendJobDetailToManagerTimer,
IHttpSender httpSender,
double interval = 500) : base(nodeConfiguration,
nodeConfiguration.GetManagerJobHasBeenCanceledTemplateUri(),
sendJobDetailToManagerTimer,
httpSender,
interval)
{
}
public TrySendJobDoneStatusToManagerTimer(NodeConfiguration nodeConfiguration,
TrySendJobDetailToManagerTimer sendJobDetailToManagerTimer,
IHttpSender httpSender,
double interval = 500) : base(nodeConfiguration,
nodeConfiguration.GetManagerJobDoneTemplateUri(),
sendJobDetailToManagerTimer,
httpSender,
interval)
{
}
public PingToManagerTimer(NodeConfiguration nodeConfiguration,
IHttpSender httpSender) : base(nodeConfiguration.PingToManagerSeconds*1000)
{
_cancellationTokenSource = new CancellationTokenSource();
_nodeConfiguration = nodeConfiguration;
_httpSender = httpSender;
_whoAmI = nodeConfiguration.CreateWhoIAm(Environment.MachineName);
Elapsed += OnTimedEvent;
}
public TrySendJobFaultedToManagerTimer(NodeConfiguration nodeConfiguration,
TrySendJobDetailToManagerTimer sendJobDetailToManagerTimer,
IHttpSender httpSender,
double interval = 500) : base(nodeConfiguration,
nodeConfiguration
.GetManagerJobHasFailedTemplatedUri(),
sendJobDetailToManagerTimer,
httpSender,
interval)
{
_httpSender = httpSender;
}
public TrySendJobDetailToManagerTimer(NodeConfiguration nodeConfiguration,
IHttpSender httpSender,
double interval = 500) : base(interval)
{
_httpSender = httpSender;
_cancellationTokenSource = new CancellationTokenSource();
_jobDetails = new ConcurrentDictionary<Guid, JobDetailEntity>();
_uriBuilder = new UriBuilder(nodeConfiguration.ManagerLocation);
_uriBuilder.Path += ManagerRouteConstants.JobProgress;
Elapsed += OnTimedEvent;
}
public void OnStartup(NodeConfiguration configuration)
{
configuration
.WcfProxyFactory
.Start<IUserService>()
.ImplementedBy<UserService>()
.ConfiguredWith(c =>
{
c.BaseAddress(Configured.From.AppSettings("UserServiceUrl"));
c.Endpoint(Bound.To(new BasicHttpBinding()));
c.PublishedMetadata();
});
}
public TrySendStatusToManagerTimer(NodeConfiguration nodeConfiguration,
Uri callbackTemplateUri,
TrySendJobDetailToManagerTimer sendJobDetailToManagerTimer,
IHttpSender httpSender, double interval = 500) : base(interval)
{
_cancellationTokenSource = new CancellationTokenSource();
_whoAmI = nodeConfiguration.CreateWhoIAm(Environment.MachineName);
_sendJobDetailToManagerTimer = sendJobDetailToManagerTimer;
_httpSender = httpSender;
CallbackTemplateUri = callbackTemplateUri;
Elapsed += OnTimedEvent;
AutoReset = true;
}
public TrySendNodeStartUpNotificationToManagerTimer(NodeConfiguration nodeConfiguration,
IHttpSender httpSender,
double interval = 5000,
bool autoReset = true) : base(interval)
{
var callbackToManagerTemplateUri = nodeConfiguration.GetManagerNodeHasBeenInitializedUri();
_cancellationTokenSource = new CancellationTokenSource();
_nodeConfiguration = nodeConfiguration;
_callbackToManagerTemplateUri = callbackToManagerTemplateUri;
_httpSender = httpSender;
_whoAmI = _nodeConfiguration.CreateWhoIAm(Environment.MachineName);
Elapsed += OnTimedEvent;
AutoReset = autoReset;
}
public void OnStartup(NodeConfiguration configuration)
{
configuration
.Container
.Put(Binding.Use(AllTypes.BasedOn<IQuery>(From.ThisAssembly)).With(Lifecycle.Unmanaged));
}
public SiloAssemblyLoader(NodeConfiguration nodeConfig)
: this(nodeConfig.AdditionalAssemblyDirectories)
{
}
public NodeTaskRunner(NodeConfiguration nodeConfiguration)
{
this.NodeConfiguration = nodeConfiguration;
}
public ClusterConfig(NodeConfiguration conf, params string[] seedNodes) : this(conf.Name, conf.Address, seedNodes)
{
}
static void Main(string[] args)
{
var config = NodeConfiguration.GetDefault();
using (var core = new CrossStitchCore(config))
{
var stitchesConfiguration = StitchesConfiguration.GetDefault();
var stitches = new StitchesModule(core, stitchesConfiguration);
core.AddModule(stitches);
var log = Common.Logging.LogManager.GetLogger("CrossStitch");
var logging = new LoggingModule(core, log);
core.AddModule(logging);
core.Start();
// First stitch is a processV1
var group1 = new StitchGroupName("StitchStart", "Client", "1");
var packageResult1 = core.MessageBus.Request <DataRequest <PackageFile>, DataResponse <PackageFile> >(DataRequest <PackageFile> .Save(new PackageFile
{
Id = group1.ToString(),
GroupName = group1,
Adaptor = new InstanceAdaptorDetails
{
Type = AdaptorType.ProcessV1,
Parameters = new Dictionary <string, string>
{
{ Parameters.DirectoryPath, "." },
{ Parameters.ExecutableName, "StitchStart.Client.exe" }
},
RequiresPackageUnzip = false
}
}, true));
var createResult1 = core.MessageBus.Request <LocalCreateInstanceRequest, LocalCreateInstanceResponse>(new LocalCreateInstanceRequest
{
Name = "StitchStart.Client",
GroupName = group1,
NumberOfInstances = 1,
});
core.MessageBus.Request <InstanceRequest, InstanceResponse>(InstanceRequest.ChannelStart, new InstanceRequest
{
Id = createResult1.CreatedIds.FirstOrDefault()
});
// Second stitch is a built-in class
var group2 = new StitchGroupName("StitchStart", "BuiltIn", "1");
var packageResult2 = core.MessageBus.Request <DataRequest <PackageFile>, DataResponse <PackageFile> >(DataRequest <PackageFile> .Save(new PackageFile
{
Id = group2.ToString(),
GroupName = group2,
Adaptor = new InstanceAdaptorDetails
{
Type = AdaptorType.BuildInClassV1,
Parameters = new Dictionary <string, string>
{
{ CrossStitch.Stitch.BuiltInClassV1.Parameters.TypeName, typeof(StitchStartBuiltInStitch).AssemblyQualifiedName }
}
},
}, true));
var createResult2 = core.MessageBus.Request <LocalCreateInstanceRequest, LocalCreateInstanceResponse>(new LocalCreateInstanceRequest
{
Name = "StitchStart.BuiltIn",
GroupName = group2,
NumberOfInstances = 1
});
core.MessageBus.Request <InstanceRequest, InstanceResponse>(InstanceRequest.ChannelStart, new InstanceRequest
{
Id = createResult2.CreatedIds.FirstOrDefault()
});
Console.ReadKey();
core.Stop();
}
}
internal MembershipEntry CreateNewMembershipEntry(NodeConfiguration nodeConf, SiloStatus myStatus)
{
return(CreateNewMembershipEntry(nodeConf, MyAddress, MyHostname, myStatus, SiloStartTime));
}
private void InitializeLogger(NodeConfiguration nodeCfg)
{
TraceLogger.Initialize(nodeCfg);
logger = TraceLogger.GetLogger("OrleansSiloHost", TraceLogger.LoggerType.Runtime);
}
public void MultidatabaseNodesToDifferentDatabaseSetTest()
{
Require.ProviderIs(StorageProvider.SqlServer);
var masterConnectionInfo = BuildConnectionToMaster(DomainConfigurationFactory.Create().ConnectionInfo);
var configuration = new DomainConfiguration(masterConnectionInfo);
configuration.Types.Register(typeof(part1.TestEntity1));
configuration.Types.Register(typeof(part2.TestEntity2));
configuration.UpgradeMode = DomainUpgradeMode.Recreate;
configuration.DefaultSchema = "dbo";
configuration.DefaultDatabase = "DO-Tests-1";
configuration.MappingRules.Map(typeof(part1.TestEntity1).Namespace).ToDatabase("DO-Tests-1");
configuration.MappingRules.Map(typeof(part2.TestEntity2).Namespace).ToDatabase("DO-Tests-2");
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1");
domainCopyNode.ConnectionInfo = masterConnectionInfo;
domainCopyNode.SchemaMapping.Add("dbo", "dbo");
domainCopyNode.DatabaseMapping.Add("DO-Tests-1", "DO-Tests-1");
domainCopyNode.DatabaseMapping.Add("DO-Tests-2", "DO-Tests-2");
domainCopyNode.UpgradeMode = DomainUpgradeMode.Recreate;
domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2");
anotherDatabaseNode.ConnectionInfo = masterConnectionInfo;
anotherDatabaseNode.SchemaMapping.Add("dbo", "dbo");
anotherDatabaseNode.DatabaseMapping.Add("DO-Tests-1", "DO-Tests-3");
anotherDatabaseNode.DatabaseMapping.Add("DO-Tests-2", "DO-Tests-4");
anotherDatabaseNode.UpgradeMode = DomainUpgradeMode.Recreate;
domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var testEntity1Type = domain.Model.Types[typeof(part1.TestEntity1)];
var testEntity2Type = domain.Model.Types[typeof(part2.TestEntity2)];
var defaultNode = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId);
var table = defaultNode.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
table = defaultNode.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-2"));
var node1 = domain.StorageNodeManager.GetNode("1");
table = node1.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
table = node1.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-2"));
var node2 = domain.StorageNodeManager.GetNode("2");
table = node2.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-3"));
table = node2.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-4"));
}
configuration = new DomainConfiguration(masterConnectionInfo);
configuration.Types.Register(typeof(part1.TestEntity1));
configuration.Types.Register(typeof(part2.TestEntity2));
configuration.UpgradeMode = DomainUpgradeMode.Skip;
configuration.DefaultSchema = "dbo";
configuration.DefaultDatabase = "DO-Tests-1";
configuration.MappingRules.Map(typeof(part1.TestEntity1).Namespace).ToDatabase("DO-Tests-1");
configuration.MappingRules.Map(typeof(part2.TestEntity2).Namespace).ToDatabase("DO-Tests-2");
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1");
domainCopyNode.ConnectionInfo = masterConnectionInfo;
domainCopyNode.SchemaMapping.Add("dbo", "dbo");
domainCopyNode.DatabaseMapping.Add("DO-Tests-1", "DO-Tests-1");
domainCopyNode.DatabaseMapping.Add("DO-Tests-2", "DO-Tests-2");
domainCopyNode.UpgradeMode = DomainUpgradeMode.Skip;
domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2");
anotherDatabaseNode.ConnectionInfo = masterConnectionInfo;
anotherDatabaseNode.SchemaMapping.Add("dbo", "dbo");
anotherDatabaseNode.DatabaseMapping.Add("DO-Tests-1", "DO-Tests-3");
anotherDatabaseNode.DatabaseMapping.Add("DO-Tests-2", "DO-Tests-4");
anotherDatabaseNode.UpgradeMode = DomainUpgradeMode.Skip;
domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var testEntity1Type = domain.Model.Types[typeof(part1.TestEntity1)];
var testEntity2Type = domain.Model.Types[typeof(part2.TestEntity2)];
var defaultNode = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId);
var table = defaultNode.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
table = defaultNode.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-2"));
var node1 = domain.StorageNodeManager.GetNode("1");
table = node1.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
table = node1.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-2"));
var node2 = domain.StorageNodeManager.GetNode("2");
table = node2.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-3"));
table = node2.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-4"));
}
}
public void MultischemaWithDatabaseSwitchingTest()
{
Require.ProviderIs(StorageProvider.SqlServer);
var masterConnection = BuildConnectionToMaster(DomainConfigurationFactory.Create().ConnectionInfo);
var configuration = new DomainConfiguration(masterConnection);
configuration.Types.Register(typeof(part1.TestEntity1));
configuration.UpgradeMode = DomainUpgradeMode.Recreate;
configuration.DefaultSchema = "dbo";
configuration.ConnectionInitializationSql = "USE [DO-Tests-1]";
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1");
domainCopyNode.ConnectionInfo = masterConnection;
domainCopyNode.ConnectionInitializationSql = "USE [DO-Tests-1]";
domainCopyNode.SchemaMapping.Add("dbo", "dbo");
domainCopyNode.UpgradeMode = DomainUpgradeMode.Recreate;
domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2");
anotherDatabaseNode.ConnectionInfo = masterConnection;
anotherDatabaseNode.ConnectionInitializationSql = "USE [DO-Tests-2]";
anotherDatabaseNode.SchemaMapping.Add("dbo", "dbo");
anotherDatabaseNode.UpgradeMode = DomainUpgradeMode.Recreate;
domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var thirdDatabaseNode = new NodeConfiguration("3");
thirdDatabaseNode.ConnectionInfo = masterConnection;
thirdDatabaseNode.ConnectionInitializationSql = "USE [DO-Tests-3]";
thirdDatabaseNode.SchemaMapping.Add("dbo", "Model1");
thirdDatabaseNode.UpgradeMode = DomainUpgradeMode.Recreate;
domain.StorageNodeManager.AddNode(thirdDatabaseNode);
}
configuration = new DomainConfiguration(masterConnection);
configuration.Types.Register(typeof(part1.TestEntity1));
configuration.DefaultSchema = "dbo";
configuration.UpgradeMode = DomainUpgradeMode.Skip;
configuration.ConnectionInitializationSql = "USE [DO-Tests-1]";
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1");
domainCopyNode.ConnectionInfo = masterConnection;
domainCopyNode.ConnectionInitializationSql = "USE [DO-Tests-1]";
domainCopyNode.SchemaMapping.Add("dbo", "dbo");
domainCopyNode.UpgradeMode = DomainUpgradeMode.Skip;
domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2");
anotherDatabaseNode.ConnectionInfo = masterConnection;
anotherDatabaseNode.ConnectionInitializationSql = "USE [DO-Tests-2]";
anotherDatabaseNode.SchemaMapping.Add("dbo", "dbo");
anotherDatabaseNode.UpgradeMode = DomainUpgradeMode.Skip;
domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var thirdDatabaseNode = new NodeConfiguration("3");
thirdDatabaseNode.ConnectionInfo = masterConnection;
thirdDatabaseNode.ConnectionInitializationSql = "USE [DO-Tests-3]";
thirdDatabaseNode.SchemaMapping.Add("dbo", "Model1");
thirdDatabaseNode.UpgradeMode = DomainUpgradeMode.Skip;
domain.StorageNodeManager.AddNode(thirdDatabaseNode);
var testEntity1Type = domain.Model.Types[typeof(part1.TestEntity1)];
var defaultNode = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId);
var table = defaultNode.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
var node1 = domain.StorageNodeManager.GetNode("1");
table = node1.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
var node2 = domain.StorageNodeManager.GetNode("2");
table = node2.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-2"));
var node3 = domain.StorageNodeManager.GetNode("3");
table = node3.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("Model1"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-3"));
}
}
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);
}
public OrleansTaskScheduler(GlobalConfiguration globalConfig, NodeConfiguration config)
: this(config.MaxActiveThreads, config.DelayWarningThreshold, config.ActivationSchedulingQuantum,
config.TurnWarningLengthThreshold, config.InjectMoreWorkerThreads)
{
}
private SiloHandle LoadSiloInNewAppDomain(string siloName, Silo.SiloType type, ClusterConfiguration config, NodeConfiguration nodeConfiguration)
{
return(AppDomainSiloHandle.Create(siloName, type, this.siloBuilderFactoryType, config, nodeConfiguration));
}
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;
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 = host.LoadSiloInNewAppDomain(siloName, type, config, out appDomain);
silo.Start();
SiloHandle retValue = new SiloHandle
{
Name = siloName,
Silo = silo,
Options = options,
Endpoint = silo.SiloAddress.Endpoint,
AppDomain = appDomain,
};
host.ImportGeneratedAssemblies(retValue);
return(retValue);
}
internal Silo(string name, SiloType siloType, ClusterConfiguration config, ILocalDataStore keyStore)
{
SystemStatus.Current = SystemStatus.Creating;
CurrentSilo = this;
var startTime = DateTime.UtcNow;
this.siloType = siloType;
Name = name;
siloTerminatedEvent = new ManualResetEvent(false);
OrleansConfig = config;
globalConfig = config.Globals;
config.OnConfigChange("Defaults", () => nodeConfig = config.GetConfigurationForNode(name));
if (!TraceLogger.IsInitialized)
{
TraceLogger.Initialize(nodeConfig);
}
config.OnConfigChange("Defaults/Tracing", () => TraceLogger.Initialize(nodeConfig, true), false);
LimitManager.Initialize(nodeConfig);
ActivationData.Init(config);
StatisticsCollector.Initialize(nodeConfig);
SerializationManager.Initialize(globalConfig.UseStandardSerializer);
initTimeout = globalConfig.MaxJoinAttemptTime;
if (Debugger.IsAttached)
{
initTimeout = StandardExtensions.Max(TimeSpan.FromMinutes(10), globalConfig.MaxJoinAttemptTime);
stopTimeout = initTimeout;
}
IPEndPoint here = nodeConfig.Endpoint;
int generation = nodeConfig.Generation;
if (generation == 0)
{
generation = SiloAddress.AllocateNewGeneration();
nodeConfig.Generation = generation;
}
TraceLogger.MyIPEndPoint = here;
logger = TraceLogger.GetLogger("Silo", TraceLogger.LoggerType.Runtime);
logger.Info(ErrorCode.SiloInitializing, "-------------- Initializing {0} silo on {1} at {2}, gen {3} --------------", siloType, nodeConfig.DNSHostName, here, generation);
logger.Info(ErrorCode.SiloInitConfig, "Starting silo {0} with runtime Version='{1}' Config= " + Environment.NewLine + "{2}", name, RuntimeVersion.Current, config.ToString(name));
if (keyStore != null)
{
// Re-establish reference to shared local key store in this app domain
LocalDataStoreInstance.LocalDataStore = keyStore;
}
healthCheckParticipants = new List <IHealthCheckParticipant>();
BufferPool.InitGlobalBufferPool(globalConfig);
PlacementStrategy.Initialize(globalConfig);
UnobservedExceptionsHandlerClass.SetUnobservedExceptionHandler(UnobservedExceptionHandler);
AppDomain.CurrentDomain.UnhandledException +=
(obj, ev) => DomainUnobservedExceptionHandler(obj, (Exception)ev.ExceptionObject);
typeManager = new GrainTypeManager(here.Address.Equals(IPAddress.Loopback));
// Performance metrics
siloStatistics = new SiloStatisticsManager(globalConfig, nodeConfig);
config.OnConfigChange("Defaults/LoadShedding", () => siloStatistics.MetricsTable.NodeConfig = nodeConfig, false);
// The scheduler
scheduler = new OrleansTaskScheduler(globalConfig, nodeConfig);
healthCheckParticipants.Add(scheduler);
// Initialize the message center
var mc = new MessageCenter(here, generation, globalConfig, siloStatistics.MetricsTable);
if (nodeConfig.IsGatewayNode)
{
mc.InstallGateway(nodeConfig.ProxyGatewayEndpoint);
}
messageCenter = mc;
// Now the router/directory service
// This has to come after the message center //; note that it then gets injected back into the message center.;
localGrainDirectory = new LocalGrainDirectory(this);
// Now the activation directory.
// This needs to know which router to use so that it can keep the global directory in synch with the local one.
activationDirectory = new ActivationDirectory();
// Now the consistent ring provider
RingProvider = GlobalConfig.UseVirtualBucketsConsistentRing ?
(IConsistentRingProvider) new VirtualBucketsRingProvider(SiloAddress, GlobalConfig.NumVirtualBucketsConsistentRing)
: new ConsistentRingProvider(SiloAddress);
Action <Dispatcher> setDispatcher;
catalog = new Catalog(Constants.CatalogId, SiloAddress, Name, LocalGrainDirectory, typeManager, scheduler, activationDirectory, config, out setDispatcher);
var dispatcher = new Dispatcher(scheduler, messageCenter, catalog, config);
setDispatcher(dispatcher);
RuntimeClient.Current = new InsideRuntimeClient(
dispatcher,
catalog,
LocalGrainDirectory,
SiloAddress,
config,
RingProvider,
typeManager);
messageCenter.RerouteHandler = InsideRuntimeClient.Current.RerouteMessage;
messageCenter.SniffIncomingMessage = InsideRuntimeClient.Current.SniffIncomingMessage;
messageCenter.ClientDropHandler = grainIds =>
{
catalog.DeleteGrainsLocal(grainIds).Ignore();
scheduler.RunOrQueueAction(() =>
{
// Consider: batch delete
foreach (var id in grainIds)
{
LocalGrainDirectory.DeleteGrain(id).Ignore();
}
}, catalog.SchedulingContext);
};
siloStatistics.MetricsTable.Scheduler = scheduler;
siloStatistics.MetricsTable.ActivationDirectory = activationDirectory;
siloStatistics.MetricsTable.ActivationCollector = catalog.ActivationCollector;
siloStatistics.MetricsTable.MessageCenter = messageCenter;
DeploymentLoadPublisher.CreateDeploymentLoadPublisher(this, globalConfig);
PlacementDirectorsManager.CreatePlacementDirectorsManager(globalConfig);
// Now the incoming message agents
incomingSystemAgent = new IncomingMessageAgent(Message.Categories.System, messageCenter, activationDirectory, scheduler, dispatcher);
incomingPingAgent = new IncomingMessageAgent(Message.Categories.Ping, messageCenter, activationDirectory, scheduler, dispatcher);
incomingAgent = new IncomingMessageAgent(Message.Categories.Application, messageCenter, activationDirectory, scheduler, dispatcher);
membershipFactory = new MembershipFactory();
reminderFactory = new LocalReminderServiceFactory();
SystemStatus.Current = SystemStatus.Created;
StringValueStatistic.FindOrCreate(StatisticNames.SILO_START_TIME,
() => TraceLogger.PrintDate(startTime)); // this will help troubleshoot production deployment when looking at MDS logs.
TestHookup = new TestHookups(this);
logger.Info(ErrorCode.SiloInitializingFinished, "-------------- Started silo {0}, ConsistentHashCode {1:X} --------------", SiloAddress.ToLongString(), SiloAddress.GetConsistentHashCode());
}
public static ClusterConfig NonSeedNode(NodeConfiguration address, INodeNetworkAddress[] seedNodesAddresses)
{
var seedNodes = seedNodesAddresses.Select(s => GetSeedNetworkAddress(address.Name, s)).ToArray();
return(new ClusterConfig(address.Name, new NodeNetworkAddress(address.Address.Host, 0), seedNodes));
}
public void OnShutdown(NodeConfiguration configuration)
{
_shutdownAction(configuration);
}
private SiloHandle LoadSiloInNewAppDomain(string siloName, Silo.SiloType type, ClusterConfiguration config, NodeConfiguration nodeConfiguration)
{
return(AppDomainSiloHandle.Create(siloName, type, config, nodeConfiguration, this.additionalAssemblies));
}
public override void Run(NodeConfiguration config, NodeFileSystem fileSystem) => WriteFileIfNotExist(Path.Combine(fileSystem.ElasticsearchHome, "run.bat"), @"bin\elasticsearch.bat");
/// <summary>
/// Base Node constructor.
/// </summary>
protected Node()
{
Current = this;
Configuration = new NodeConfiguration();
}
public async Task CreateOpcEventPublishingData(string testFilename, int configuredSessions,
int configuredSubscriptions, int configuredMonitoredItems, int configuredMonitoredEvents)
{
string methodName = UnitTestHelper.GetMethodName();
string fqTempFilename = string.Empty;
string fqTestFilename = $"{Directory.GetCurrentDirectory()}/testdata/event/{testFilename}";
fqTempFilename = $"{Directory.GetCurrentDirectory()}/tempdata/{methodName}_{testFilename}";
if (File.Exists(fqTempFilename))
{
File.Delete(fqTempFilename);
}
File.Copy(fqTestFilename, fqTempFilename);
PublisherNodeConfiguration.PublisherNodeConfigurationFilename = fqTempFilename;
_output.WriteLine($"now testing: {PublisherNodeConfiguration.PublisherNodeConfigurationFilename}");
Assert.True(File.Exists(PublisherNodeConfiguration.PublisherNodeConfigurationFilename));
UnitTestHelper.SetPublisherDefaults();
try
{
NodeConfiguration = PublisherNodeConfiguration.Instance;
Assert.True(NodeConfiguration.OpcSessions.Count == configuredSessions, "wrong # of sessions");
Assert.True(NodeConfiguration.NumberOfOpcSessionsConfigured == configuredSessions, "wrong # of sessions");
Assert.True(NodeConfiguration.NumberOfOpcSubscriptionsConfigured == configuredSubscriptions, "wrong # of subscriptions");
Assert.True(NodeConfiguration.NumberOfOpcEventMonitoredItemsConfigured == configuredMonitoredEvents, "wrong # of events");
Assert.True(NodeConfiguration.NumberOfOpcDataChangeMonitoredItemsConfigured == configuredMonitoredItems, "wrong # of monitored items");
_output.WriteLine($"sessions configured {NodeConfiguration.NumberOfOpcSessionsConfigured}, connected {NodeConfiguration.NumberOfOpcSessionsConnected}");
_output.WriteLine($"subscriptions configured {NodeConfiguration.NumberOfOpcSubscriptionsConfigured}, connected {NodeConfiguration.NumberOfOpcSubscriptionsConnected}");
_output.WriteLine($"items configured {NodeConfiguration.NumberOfOpcDataChangeMonitoredItemsConfigured}, monitored {NodeConfiguration.NumberOfOpcDataChangeMonitoredItemsMonitored}, " +
$"toRemove {NodeConfiguration.NumberOfOpcDataChangeMonitoredItemsToRemove}, events configured {NodeConfiguration.NumberOfOpcEventMonitoredItemsConfigured}, " +
$"monitored {NodeConfiguration.NumberOfOpcEventMonitoredItemsMonitored}");
await NodeConfiguration.UpdateNodeConfigurationFileAsync().ConfigureAwait(false);
_configurationFileEntries = new List <PublisherConfigurationFileEntryLegacyModel>();
_configurationFileEntries = JsonConvert.DeserializeObject <List <PublisherConfigurationFileEntryLegacyModel> >(File.ReadAllText(PublisherNodeConfiguration.PublisherNodeConfigurationFilename));
Assert.True(_configurationFileEntries[0].OpcEvents.Count == 1);
Assert.True(_configurationFileEntries[0].OpcEvents[0].Id == "i=2253");
Assert.True(_configurationFileEntries[0].OpcEvents[0].DisplayName == "SimpleEventServerEvents");
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses.Count == 4);
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[0].TypeId == "i=2041");
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[0].IotCentralEventPublishMode ==
IotCentralEventPublishMode.Property);
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[0].BrowsePaths[0] == "EventId");
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[1].TypeId == "i=2041");
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[1].IotCentralEventPublishMode ==
IotCentralEventPublishMode.Default);
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[1].BrowsePaths[0] == "Message");
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[2].TypeId == "nsu=http://opcfoundation.org/Quickstarts/SimpleEvents;i=235");
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[2].IotCentralEventPublishMode ==
IotCentralEventPublishMode.Default);
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[2].BrowsePaths[0] == "/2:CycleId");
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[3].TypeId == "nsu=http://opcfoundation.org/Quickstarts/SimpleEvents;i=235");
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[3].IotCentralEventPublishMode ==
IotCentralEventPublishMode.Default);
Assert.True(_configurationFileEntries[0].OpcEvents[0].SelectClauses[3].BrowsePaths[0] == "/2:CurrentStep");
Assert.True(_configurationFileEntries[0].OpcEvents[0].WhereClause.Count == 1);
Assert.True(_configurationFileEntries[0].OpcEvents[0].WhereClause[0].Operator == "OfType");
Assert.True(_configurationFileEntries[0].OpcEvents[0].WhereClause[0].Operands.Count == 1);
Assert.True(_configurationFileEntries[0].OpcEvents[0].WhereClause[0].Operands[0].Literal == "ns=2;i=235");
}
finally
{
NodeConfiguration.Dispose();
NodeConfiguration = null;
}
}
/// <summary>
/// Handles the NodeConfiguration packet.
/// </summary>
private void HandleNodeConfiguration(NodeConfiguration configuration)
{
// Grab the system parameters.
_buildParameters = configuration.BuildParameters;
_buildParameters.ProjectRootElementCache = s_projectRootElementCacheBase;
// Snapshot the current environment
_savedEnvironment = CommunicationsUtilities.GetEnvironmentVariables();
// Change to the startup directory
try
{
NativeMethodsShared.SetCurrentDirectory(BuildParameters.StartupDirectory);
}
catch (DirectoryNotFoundException)
{
// Somehow the startup directory vanished. This can happen if build was started from a USB Key and it was removed.
NativeMethodsShared.SetCurrentDirectory(BuildEnvironmentHelper.Instance.CurrentMSBuildToolsDirectory);
}
// Replicate the environment. First, unset any environment variables set by the previous configuration.
if (_currentConfiguration != null)
{
foreach (string key in _currentConfiguration.BuildParameters.BuildProcessEnvironment.Keys)
{
Environment.SetEnvironmentVariable(key, null);
}
}
// Now set the new environment
foreach (KeyValuePair <string, string> environmentPair in _buildParameters.BuildProcessEnvironment)
{
Environment.SetEnvironmentVariable(environmentPair.Key, environmentPair.Value);
}
// We want to make sure the global project collection has the toolsets which were defined on the parent
// so that any custom toolsets defined can be picked up by tasks who may use the global project collection but are
// executed on the child node.
ICollection <Toolset> parentToolSets = _buildParameters.ToolsetProvider.Toolsets;
if (parentToolSets != null)
{
ProjectCollection.GlobalProjectCollection.RemoveAllToolsets();
foreach (Toolset toolSet in parentToolSets)
{
ProjectCollection.GlobalProjectCollection.AddToolset(toolSet);
}
}
// Set the culture.
CultureInfo.CurrentCulture = _buildParameters.Culture;
CultureInfo.CurrentUICulture = _buildParameters.UICulture;
// Get the node ID.
_buildParameters.NodeId = configuration.NodeId;
_buildParameters.IsOutOfProc = true;
#if FEATURE_APPDOMAIN
// And the AppDomainSetup
_buildParameters.AppDomainSetup = configuration.AppDomainSetup;
#endif
// Set up the logging service.
LoggingServiceFactory loggingServiceFactory = new LoggingServiceFactory(LoggerMode.Asynchronous, configuration.NodeId);
_componentFactories.ReplaceFactory(BuildComponentType.LoggingService, loggingServiceFactory.CreateInstance);
_loggingService = _componentFactories.GetComponent(BuildComponentType.LoggingService) as ILoggingService;
BuildEventArgTransportSink sink = new BuildEventArgTransportSink(SendPacket);
_shutdownException = null;
if (configuration.LoggingNodeConfiguration.IncludeEvaluationMetaprojects)
{
_loggingService.IncludeEvaluationMetaprojects = true;
}
if (configuration.LoggingNodeConfiguration.IncludeEvaluationProfiles)
{
_loggingService.IncludeEvaluationProfile = true;
}
if (configuration.LoggingNodeConfiguration.IncludeTaskInputs)
{
_loggingService.IncludeTaskInputs = true;
}
try
{
// If there are no node loggers to initialize dont do anything
if (configuration.LoggerDescriptions?.Length > 0)
{
_loggingService.InitializeNodeLoggers(configuration.LoggerDescriptions, sink, configuration.NodeId);
}
}
catch (Exception ex)
{
if (ExceptionHandling.IsCriticalException(ex))
{
throw;
}
OnEngineException(ex);
}
_loggingService.OnLoggingThreadException += OnLoggingThreadException;
string forwardPropertiesFromChild = Environment.GetEnvironmentVariable("MSBUILDFORWARDPROPERTIESFROMCHILD");
string[] propertyListToSerialize = null;
// Get a list of properties which should be serialized
if (!String.IsNullOrEmpty(forwardPropertiesFromChild))
{
propertyListToSerialize = forwardPropertiesFromChild.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries);
}
_loggingService.PropertiesToSerialize = propertyListToSerialize;
_loggingService.RunningOnRemoteNode = true;
string forwardAllProperties = Environment.GetEnvironmentVariable("MSBUILDFORWARDALLPROPERTIESFROMCHILD");
if (String.Equals(forwardAllProperties, "1", StringComparison.OrdinalIgnoreCase) || _buildParameters.LogInitialPropertiesAndItems)
{
_loggingService.SerializeAllProperties = true;
}
else
{
_loggingService.SerializeAllProperties = false;
}
// Now prep the buildRequestEngine for the build.
_loggingContext = new NodeLoggingContext(_loggingService, configuration.NodeId, false /* inProcNode */);
if (_shutdownException != null)
{
HandleShutdown(out Exception exception);
throw exception;
}
_buildRequestEngine.InitializeForBuild(_loggingContext);
// Finally store off this configuration packet.
_currentConfiguration = configuration;
}
private SiloHandle _StartOrleansSilo(Silo.SiloType type, UnitTestSiloOptions options, 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 ? options.BasePort : 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;
globalConfig = config.Globals;
string siloName;
switch (type)
{
case Silo.SiloType.Primary:
siloName = "Primary";
break;
default:
siloName = "Secondary_" + InstanceCounter.ToString(CultureInfo.InvariantCulture);
break;
}
NodeConfiguration nodeConfig = config.GetConfigurationForNode(siloName);
nodeConfig.HostNameOrIPAddress = "loopback";
nodeConfig.Port = basePort + InstanceCounter;
nodeConfig.DefaultTraceLevel = config.Defaults.DefaultTraceLevel;
nodeConfig.PropagateActivityId = config.Defaults.PropagateActivityId;
nodeConfig.BulkMessageLimit = config.Defaults.BulkMessageLimit;
config.Globals.ExpectedClusterSize = 2;
config.Overrides[siloName] = nodeConfig;
InstanceCounter++;
Console.WriteLine("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,
};
return(retValue);
}
/// <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, IDictionary <string, GeneratedAssembly> additionalAssemblies, string applicationBase = null)
{
AppDomainSetup setup = GetAppDomainSetupInfo(applicationBase);
var appDomain = AppDomain.CreateDomain(siloName, null, setup);
try
{
// 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;
siloHost.Start();
var retValue = new AppDomainSiloHandle
{
Name = siloName,
SiloHost = siloHost,
NodeConfiguration = nodeConfiguration,
SiloAddress = siloHost.SiloAddress,
Type = type,
AppDomain = appDomain,
additionalAssemblies = additionalAssemblies,
AppDomainTestHook = siloHost.AppDomainTestHook,
};
retValue.ImportGeneratedAssemblies();
return(retValue);
}
catch (Exception)
{
UnloadAppDomain(appDomain);
throw;
}
}
public OrleansTaskScheduler(GlobalConfiguration globalConfig, NodeConfiguration config)
: this(config.MaxActiveThreads, config.DelayWarningThreshold, config.ActivationSchedulingQuantum,
config.TurnWarningLengthThreshold, config.InjectMoreWorkerThreads, config.LimitManager.GetLimit(LimitNames.LIMIT_MAX_PENDING_ITEMS))
{
}
public NodeInfoMessage(NodeConfiguration nodeConfiguration, Hash receiverNodeId) : base(NodeMessageTypes.NodeInfo, nodeConfiguration, receiverNodeId)
{
}
public void OnConfigure(NodeConfiguration configuration)
{
_configurationAction(configuration);
}
public static void Init(ClusterConfiguration config, NodeConfiguration nodeConfig)
{
// Consider adding a config parameter for this
maxRequestProcessingTime = config.Globals.ResponseTimeout.Multiply(5);
nodeConfiguration = nodeConfig;
}
public abstract void Validate(IElasticClient client, NodeConfiguration configuration);
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);
}
public static string ToRootSelectionPath(this NodeConfiguration adr)
{
return($"akka.tcp://{adr.Name}@{adr.Address.Host}:{adr.Address.PortNumber}/user");
}
public void OnStartup(NodeConfiguration configuration)
{
configuration
.WcfProxyFactory
.Consume<IUserService>(Bound.To(new BasicHttpBinding()).AtUrl(Configured.From.AppSettings("UserServiceUrl")));
}
/// <summary>
/// Initializes a new instance of the <see cref="OrleansFabricEndpoints" /> class.
/// </summary>
/// <param name="config">
/// The node configuration to initialize from.
/// </param>
public OrleansFabricEndpoints(NodeConfiguration config)
{
this.Silo = SiloAddress.New(config.Endpoint, config.Generation).ToParsableString();
this.Gateway = SiloAddress.New(config.ProxyGatewayEndpoint, config.Generation).ToParsableString();
}
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 void OnStartup(NodeConfiguration configuration)
{
_startupAction(configuration);
}
/// <summary>
/// Handle method call to get list of configured nodes on a specific endpoint.
/// </summary>
public virtual Task <MethodResponse> HandleGetConfiguredEventsOnEndpointMethodAsync(MethodRequest methodRequest, object userContext)
{
const string logPrefix = "HandleGetConfiguredEventsOnEndpointMethodAsync:";
Guid endpointId = Guid.Empty;
string endpointName = null;
string endpointUrl = null;
GetConfiguredNodesOnEndpointMethodRequestModel getConfiguredEventNodesOnEndpointMethodRequest = null;
uint nodeConfigVersion = 0;
GetConfiguredEventNodesOnEndpointMethodResponseModel getConfiguredEventNodesOnEndpointMethodResponse = new GetConfiguredEventNodesOnEndpointMethodResponseModel();
uint actualNodeCount = 0;
uint availableEventNodeCount = 0;
var opcEvents = new List <OpcEventOnEndpointModel>();
uint startIndex = 0;
var statusCode = HttpStatusCode.OK;
var statusResponse = new List <string>();
string statusMessage;
try
{
Logger.Debug($"{logPrefix} called");
getConfiguredEventNodesOnEndpointMethodRequest = JsonConvert.DeserializeObject <GetConfiguredNodesOnEndpointMethodRequestModel>(methodRequest.DataAsJson);
if (getConfiguredEventNodesOnEndpointMethodRequest.EndpointId == null)
{
statusMessage = $"New endpoint: there are no event nodes configured";
Logger.Information($"{logPrefix} {statusMessage}");
statusResponse.Add(statusMessage);
statusCode = HttpStatusCode.NoContent;
}
else
{
endpointId = new Guid(getConfiguredEventNodesOnEndpointMethodRequest.EndpointId);
}
}
catch (FormatException e)
{
statusMessage = $"Exception ({e.Message}) while parsing EndpointId '{getConfiguredEventNodesOnEndpointMethodRequest?.EndpointId}'";
Logger.Error(e, $"{logPrefix} {statusMessage}");
statusResponse.Add(statusMessage);
statusCode = HttpStatusCode.InternalServerError;
}
catch (Exception e)
{
statusMessage = $"Exception ({e.Message}) while deserializing message payload";
Logger.Error(e, $"{logPrefix} Exception");
statusResponse.Add(statusMessage);
statusCode = HttpStatusCode.InternalServerError;
}
if (statusCode == HttpStatusCode.OK)
{
// get the list of published nodes for the endpoint
List <PublisherConfigurationFileEntryModel> configFileEntries = NodeConfiguration.GetPublisherConfigurationFileEntries(endpointId, false, out nodeConfigVersion);
// return if there are no nodes configured for this endpoint
if (configFileEntries.Count == 0)
{
statusMessage = $"There are no event nodes configured for endpoint '{endpointId.ToString()}'";
Logger.Information($"{logPrefix} {statusMessage}");
statusResponse.Add(statusMessage);
statusCode = HttpStatusCode.NoContent;
}
else
{
endpointName = configFileEntries.First().EndpointName;
endpointUrl = configFileEntries.First().EndpointUrl.ToString();
foreach (var configFileEntry in configFileEntries)
{
if (configFileEntry?.OpcEvents != null)
{
opcEvents.AddRange(configFileEntry.OpcEvents);
}
}
uint configuredEventNodesOnEndpointCount = (uint)opcEvents.Count();
// validate version
startIndex = 0;
if (getConfiguredEventNodesOnEndpointMethodRequest?.ContinuationToken != null)
{
uint requestedNodeConfigVersion = (uint)(getConfiguredEventNodesOnEndpointMethodRequest.ContinuationToken >> 32);
if (nodeConfigVersion != requestedNodeConfigVersion)
{
statusMessage = $"The event node configuration has changed between calls. Requested version: {requestedNodeConfigVersion:X8}, Current version '{nodeConfigVersion:X8}'!";
Logger.Information($"{logPrefix} {statusMessage}");
statusResponse.Add(statusMessage);
statusCode = HttpStatusCode.Gone;
}
startIndex = (uint)(getConfiguredEventNodesOnEndpointMethodRequest.ContinuationToken & 0x0FFFFFFFFL);
}
if (statusCode == HttpStatusCode.OK)
{
// set count
var requestedEventNodeCount = configuredEventNodesOnEndpointCount - startIndex;
availableEventNodeCount = configuredEventNodesOnEndpointCount - startIndex;
actualNodeCount = Math.Min(requestedEventNodeCount, availableEventNodeCount);
opcEvents.ForEach(x => x.OpcPublisherPublishState = OpcPublisherPublishState.Published);
// generate response
while (true)
{
string publishedNodesString = JsonConvert.SerializeObject(opcEvents.GetRange((int)startIndex, (int)actualNodeCount));
var publishedNodesByteArray = Encoding.UTF8.GetBytes(publishedNodesString);
if (publishedNodesByteArray.Length > MaxResponsePayloadLength)
{
actualNodeCount /= 2;
continue;
}
break;
}
}
}
}
// build response
string resultString;
if (statusCode == HttpStatusCode.OK)
{
getConfiguredEventNodesOnEndpointMethodResponse.ContinuationToken = null;
if (actualNodeCount < availableEventNodeCount)
{
getConfiguredEventNodesOnEndpointMethodResponse.ContinuationToken = (ulong)nodeConfigVersion << 32 | actualNodeCount + startIndex;
}
// Todo: check if EventConfigurationModel mit endpointName = endpointUrl = null ok?
getConfiguredEventNodesOnEndpointMethodResponse.EventNodes
.AddRange(opcEvents
.GetRange((int)startIndex, (int)actualNodeCount)
.Select(n =>
new OpcEventOnEndpointModel(
new EventConfigurationModel(
endpointId.ToString(),
endpointName,
endpointUrl,
null,
OpcAuthenticationMode.Anonymous,
null,
n.Id,
n.DisplayName,
n.SelectClauses,
n.WhereClause,
n.IotCentralEventPublishMode
),
OpcPublisherPublishState.Published
)
)
);
getConfiguredEventNodesOnEndpointMethodResponse.EndpointId = endpointId.ToString();
resultString = JsonConvert.SerializeObject(getConfiguredEventNodesOnEndpointMethodResponse);
Logger.Information($"{logPrefix} Success returning {actualNodeCount} event node(s) of {availableEventNodeCount} (start: {startIndex}) (node config version: {nodeConfigVersion:X8})!");
}
else if (statusCode == HttpStatusCode.NoContent)
{
resultString = JsonConvert.SerializeObject(getConfiguredEventNodesOnEndpointMethodResponse);
Logger.Information($"{logPrefix} Success returning 0 event nodes.");
}
else
{
resultString = JsonConvert.SerializeObject(statusResponse);
}
byte[] result = Encoding.UTF8.GetBytes(resultString);
if (result.Length > MaxResponsePayloadLength)
{
Logger.Error($"{logPrefix} Response size is too long");
Array.Resize(ref result, result.Length > MaxResponsePayloadLength ? MaxResponsePayloadLength : result.Length);
}
MethodResponse methodResponse = new MethodResponse(result, (int)statusCode);
Logger.Information($"{logPrefix} completed with result {statusCode.ToString()}");
return(Task.FromResult(methodResponse));
}
