public SiloProviderRuntime(
ILocalSiloDetails siloDetails,
IOptions <ClusterOptions> clusterOptions,
IConsistentRingProvider consistentRingProvider,
ISiloRuntimeClient runtimeClient,
ImplicitStreamSubscriberTable implicitStreamSubscriberTable,
ISiloStatusOracle siloStatusOracle,
OrleansTaskScheduler scheduler,
ActivationDirectory activationDirectory,
ILoggerFactory loggerFactory)
{
this.loggerFactory = loggerFactory;
this.siloStatusOracle = siloStatusOracle;
this.scheduler = scheduler;
this.activationDirectory = activationDirectory;
this.consistentRingProvider = consistentRingProvider;
this.runtimeClient = runtimeClient;
this.ServiceId = clusterOptions.Value.ServiceId;
this.SiloIdentity = siloDetails.SiloAddress.ToLongString();
this.grainBasedPubSub = new GrainBasedPubSubRuntime(this.GrainFactory);
var tmp = new ImplicitStreamPubSub(this.runtimeClient.InternalGrainFactory, implicitStreamSubscriberTable);
this.implictPubSub = tmp;
this.combinedGrainBasedAndImplicitPubSub = new StreamPubSubImpl(this.grainBasedPubSub, tmp);
}
public SiloProviderRuntime(
SiloInitializationParameters siloDetails,
GlobalConfiguration config,
IGrainFactory grainFactory,
IConsistentRingProvider consistentRingProvider,
ISiloRuntimeClient runtimeClient,
IServiceProvider serviceProvider,
ImplicitStreamSubscriberTable implicitStreamSubscriberTable,
ISiloStatusOracle siloStatusOracle,
OrleansTaskScheduler scheduler,
ActivationDirectory activationDirectory)
{
this.siloDetails = siloDetails;
this.siloStatusOracle = siloStatusOracle;
this.scheduler = scheduler;
this.activationDirectory = activationDirectory;
this.consistentRingProvider = consistentRingProvider;
this.runtimeClient = runtimeClient;
this.ServiceId = config.ServiceId;
this.SiloIdentity = siloDetails.SiloAddress.ToLongString();
this.GrainFactory = grainFactory;
this.ServiceProvider = serviceProvider;
this.grainBasedPubSub = new GrainBasedPubSubRuntime(this.GrainFactory);
var tmp = new ImplicitStreamPubSub(implicitStreamSubscriberTable);
this.implictPubSub = tmp;
this.combinedGrainBasedAndImplicitPubSub = new StreamPubSubImpl(this.grainBasedPubSub, tmp);
}
public MessageCenter(
ILocalSiloDetails siloDetails,
MessageFactory messageFactory,
Catalog catalog,
Factory <MessageCenter, Gateway> gatewayFactory,
ILogger <MessageCenter> logger,
ISiloStatusOracle siloStatusOracle,
ConnectionManager senderManager,
RuntimeMessagingTrace messagingTrace,
IOptions <SiloMessagingOptions> messagingOptions,
PlacementService placementService,
ILocalGrainDirectory localGrainDirectory,
ActivationDirectory activationDirectory)
{
this.catalog = catalog;
this.messagingOptions = messagingOptions.Value;
this.siloStatusOracle = siloStatusOracle;
this.connectionManager = senderManager;
this.messagingTrace = messagingTrace;
this.placementService = placementService;
this.localGrainDirectory = localGrainDirectory;
this.activationDirectory = activationDirectory;
this.log = logger;
this.messageFactory = messageFactory;
this._siloAddress = siloDetails.SiloAddress;
if (siloDetails.GatewayAddress != null)
{
Gateway = gatewayFactory(this);
}
}
internal IncomingMessageAgent(Message.Categories cat, IMessageCenter mc, ActivationDirectory ad, OrleansTaskScheduler sched, Dispatcher dispatcher) :
base(cat.ToString())
{
category = cat;
messageCenter = mc;
directory = ad;
scheduler = sched;
this.dispatcher = dispatcher;
OnFault = FaultBehavior.RestartOnFault;
}
internal IncomingMessageAgent(Message.Categories cat, IMessageCenter mc, ActivationDirectory ad, OrleansTaskScheduler sched, Dispatcher dispatcher) :
base(cat.ToString())
{
category = cat;
messageCenter = mc;
directory = ad;
scheduler = sched;
this.dispatcher = dispatcher;
OnFault = FaultBehavior.RestartOnFault;
}
public MessageCenter(IServiceProvider serviceProvider)
{
this.activationDirectory = serviceProvider.GetRequiredService <ActivationDirectory>();
this.connectionManager = serviceProvider.GetRequiredService <ConnectionManager>();
this.gatewayMembershipServiceOptions = serviceProvider.GetService <GatewayMembershipServiceOptions>();
this.clusterMembershipServiceOptions = serviceProvider.GetService <ClusterMembershipServiceOptions>();
this.hostingLifecycle = serviceProvider.GetRequiredService <IServiceHostLifecycle>();
this.taskScheduler = serviceProvider.GetRequiredService <TaskScheduler>();
this.cancellationToken = hostingLifecycle.Token;
}
internal IncomingMessageHandler(
MessageCenter mc,
ActivationDirectory ad,
OrleansTaskScheduler sched,
Dispatcher dispatcher,
MessageFactory messageFactory,
ILogger <IncomingMessageHandler> log,
MessagingTrace messagingTrace)
{
this.messageCenter = mc;
this.directory = ad;
this.scheduler = sched;
this.dispatcher = dispatcher;
this.messageFactory = messageFactory;
this.log = log;
this.messagingTrace = messagingTrace;
}
internal IncomingMessageAgent(
Message.Categories cat,
IMessageCenter mc,
ActivationDirectory ad,
OrleansTaskScheduler sched,
Dispatcher dispatcher,
MessageFactory messageFactory,
ExecutorService executorService,
ILoggerFactory loggerFactory) :
base(cat.ToString(), executorService, loggerFactory)
{
category = cat;
messageCenter = mc;
directory = ad;
scheduler = sched;
this.dispatcher = dispatcher;
this.messageFactory = messageFactory;
OnFault = FaultBehavior.RestartOnFault;
}
internal IncomingMessageAgent(
Message.Categories cat,
IMessageCenter mc,
ActivationDirectory ad,
OrleansTaskScheduler sched,
Dispatcher dispatcher,
MessageFactory messageFactory,
ILoggerFactory loggerFactory) :
base(cat.ToString(), loggerFactory)
{
category = cat;
messageCenter = mc;
directory = ad;
scheduler = sched;
this.dispatcher = dispatcher;
this.messageFactory = messageFactory;
OnFault = FaultBehavior.RestartOnFault;
messageCenter.RegisterLocalMessageHandler(cat, ReceiveMessage);
}
protected internal override void Initialize()
{
base.Initialize();
this.membershipServiceOptions = ServiceProvider.GetRequiredService <GatewayMembershipServiceOptions>();
this.activationDirectory = ServiceProvider.GetRequiredService <ActivationDirectory>();
this.addressableDirectory = ServiceProvider.GetRequiredService <AddressableDirectory>();
this.membershipManager = ServiceProvider.GetRequiredService <MembershipManager>();
this.hostingLifecycle = ServiceProvider.GetRequiredService <IServiceHostLifecycle>();
Address = membershipServiceOptions.OutsideAddress;
Identity = Identity.NewIdentity(Identity.Categories.SystemTarget);
membershipEntry = new MembershipEntry();
membershipEntry.Identity = Identity;
membershipEntry.Address = Address;
clusterMembershipService = ServiceFactory.GetSystemTarget <IClusterMembershipService>(Constants.ClusterMembershipServiceIdentity, membershipServiceOptions.Cluster);
var lifecycle = ServiceProvider.GetRequiredService <IDirectoryLifecycle>();
lifecycle.Subscribe(nameof(GatewayMembershipService), Lifecycles.Stage.System, this);
}
public SiloProviderRuntime(
IConsistentRingProvider consistentRingProvider,
ISiloRuntimeClient runtimeClient,
ImplicitStreamSubscriberTable implicitStreamSubscriberTable,
OrleansTaskScheduler scheduler,
ActivationDirectory activationDirectory,
ILoggerFactory loggerFactory,
ILocalSiloDetails siloDetails)
{
this.loggerFactory = loggerFactory;
this.siloDetails = siloDetails;
this.scheduler = scheduler;
this.activationDirectory = activationDirectory;
this.consistentRingProvider = consistentRingProvider;
this.runtimeClient = runtimeClient;
this.logger = this.loggerFactory.CreateLogger <SiloProviderRuntime>();
this.grainBasedPubSub = new GrainBasedPubSubRuntime(this.GrainFactory);
var tmp = new ImplicitStreamPubSub(this.runtimeClient.InternalGrainFactory, implicitStreamSubscriberTable);
this.implictPubSub = tmp;
this.combinedGrainBasedAndImplicitPubSub = new StreamPubSubImpl(this.grainBasedPubSub, tmp);
}
internal Catalog(
GrainId grainId,
SiloAddress silo,
string siloName,
ILocalGrainDirectory grainDirectory,
GrainTypeManager typeManager,
OrleansTaskScheduler scheduler,
ActivationDirectory activationDirectory,
ClusterConfiguration config,
IGrainRuntime grainRuntime,
out Action<Dispatcher> setDispatcher)
: base(grainId, silo)
{
LocalSilo = silo;
localSiloName = siloName;
directory = grainDirectory;
activations = activationDirectory;
this.scheduler = scheduler;
GrainTypeManager = typeManager;
this.grainRuntime = grainRuntime;
collectionNumber = 0;
destroyActivationsNumber = 0;
logger = TraceLogger.GetLogger("Catalog", TraceLogger.LoggerType.Runtime);
this.config = config.Globals;
setDispatcher = d => dispatcher = d;
ActivationCollector = new ActivationCollector(config);
GC.GetTotalMemory(true); // need to call once w/true to ensure false returns OK value
config.OnConfigChange("Globals/Activation", () => scheduler.RunOrQueueAction(Start, SchedulingContext), false);
IntValueStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_COUNT, () => activations.Count);
activationsCreated = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_CREATED);
activationsDestroyed = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_DESTROYED);
activationsFailedToActivate = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_FAILED_TO_ACTIVATE);
collectionCounter = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_COLLECTION_NUMBER_OF_COLLECTIONS);
inProcessRequests = IntValueStatistic.FindOrCreate(StatisticNames.MESSAGING_PROCESSING_ACTIVATION_DATA_ALL, () =>
{
long counter = 0;
lock (activations)
{
foreach (var activation in activations)
{
ActivationData data = activation.Value;
counter += data.GetRequestCount();
}
}
return counter;
});
}
public Catalog(
SiloInitializationParameters siloInitializationParameters,
ILocalGrainDirectory grainDirectory,
GrainTypeManager typeManager,
OrleansTaskScheduler scheduler,
ActivationDirectory activationDirectory,
ClusterConfiguration config,
GrainCreator grainCreator,
NodeConfiguration nodeConfig,
ISiloMessageCenter messageCenter,
PlacementDirectorsManager placementDirectorsManager)
: base(Constants.CatalogId, messageCenter.MyAddress)
{
LocalSilo = siloInitializationParameters.SiloAddress;
localSiloName = siloInitializationParameters.Name;
directory = grainDirectory;
activations = activationDirectory;
this.scheduler = scheduler;
GrainTypeManager = typeManager;
collectionNumber = 0;
destroyActivationsNumber = 0;
this.grainCreator = grainCreator;
this.nodeConfig = nodeConfig;
logger = LogManager.GetLogger("Catalog", Runtime.LoggerType.Runtime);
this.config = config.Globals;
ActivationCollector = new ActivationCollector(config);
this.Dispatcher = new Dispatcher(scheduler, messageCenter, this, config, placementDirectorsManager);
GC.GetTotalMemory(true); // need to call once w/true to ensure false returns OK value
config.OnConfigChange("Globals/Activation", () => scheduler.RunOrQueueAction(Start, SchedulingContext), false);
IntValueStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_COUNT, () => activations.Count);
activationsCreated = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_CREATED);
activationsDestroyed = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_DESTROYED);
activationsFailedToActivate = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_FAILED_TO_ACTIVATE);
collectionCounter = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_COLLECTION_NUMBER_OF_COLLECTIONS);
inProcessRequests = IntValueStatistic.FindOrCreate(StatisticNames.MESSAGING_PROCESSING_ACTIVATION_DATA_ALL, () =>
{
long counter = 0;
lock (activations)
{
foreach (var activation in activations)
{
ActivationData data = activation.Value;
counter += data.GetRequestCount();
}
}
return counter;
});
maxWarningRequestProcessingTime = this.config.ResponseTimeout.Multiply(5);
maxRequestProcessingTime = this.config.MaxRequestProcessingTime;
}
internal Silo(SiloInitializationParameters initializationParams)
{
string name = initializationParams.Name;
ClusterConfiguration config = initializationParams.ClusterConfig;
this.initializationParams = initializationParams;
SystemStatus.Current = SystemStatus.Creating;
CurrentSilo = this;
var startTime = DateTime.UtcNow;
siloTerminatedEvent = new ManualResetEvent(false);
if (!LogManager.IsInitialized)
LogManager.Initialize(LocalConfig);
config.OnConfigChange("Defaults/Tracing", () => LogManager.Initialize(LocalConfig, true), false);
MultiClusterRegistrationStrategy.Initialize(config.Globals);
StatisticsCollector.Initialize(LocalConfig);
SerializationManager.Initialize(GlobalConfig.SerializationProviders, this.GlobalConfig.FallbackSerializationProvider);
initTimeout = GlobalConfig.MaxJoinAttemptTime;
if (Debugger.IsAttached)
{
initTimeout = StandardExtensions.Max(TimeSpan.FromMinutes(10), GlobalConfig.MaxJoinAttemptTime);
stopTimeout = initTimeout;
}
var localEndpoint = this.initializationParams.SiloAddress.Endpoint;
LogManager.MyIPEndPoint = localEndpoint;
logger = LogManager.GetLogger("Silo", LoggerType.Runtime);
logger.Info(ErrorCode.SiloGcSetting, "Silo starting with GC settings: ServerGC={0} GCLatencyMode={1}", GCSettings.IsServerGC, Enum.GetName(typeof(GCLatencyMode), GCSettings.LatencyMode));
if (!GCSettings.IsServerGC || !GCSettings.LatencyMode.Equals(GCLatencyMode.Batch))
{
logger.Warn(ErrorCode.SiloGcWarning, "Note: Silo not running with ServerGC turned on or with GCLatencyMode.Batch enabled - recommend checking app config : <configuration>-<runtime>-<gcServer enabled=\"true\"> and <configuration>-<runtime>-<gcConcurrent enabled=\"false\"/>");
logger.Warn(ErrorCode.SiloGcWarning, "Note: ServerGC only kicks in on multi-core systems (settings enabling ServerGC have no effect on single-core machines).");
}
logger.Info(ErrorCode.SiloInitializing, "-------------- Initializing {0} silo on host {1} MachineName {2} at {3}, gen {4} --------------",
this.initializationParams.Type, LocalConfig.DNSHostName, Environment.MachineName, localEndpoint, this.initializationParams.SiloAddress.Generation);
logger.Info(ErrorCode.SiloInitConfig, "Starting silo {0} with the following configuration= " + Environment.NewLine + "{1}",
name, config.ToString(name));
// Configure DI using Startup type
this.Services = StartupBuilder.ConfigureStartup(
this.LocalConfig.StartupTypeName,
(services, usingCustomServiceProvider) =>
{
// add system types
// Note: you can replace IGrainFactory with your own implementation, but
// we don't recommend it, in the aspect of performance and usability
services.TryAddSingleton(sp => sp);
services.TryAddSingleton(this);
services.TryAddSingleton(initializationParams);
services.TryAddSingleton<ILocalSiloDetails>(initializationParams);
services.TryAddSingleton(initializationParams.ClusterConfig);
services.TryAddSingleton(initializationParams.GlobalConfig);
services.TryAddTransient(sp => initializationParams.NodeConfig);
services.TryAddSingleton<ITimerRegistry, TimerRegistry>();
services.TryAddSingleton<IReminderRegistry, ReminderRegistry>();
services.TryAddSingleton<IStreamProviderManager, StreamProviderManager>();
services.TryAddSingleton<GrainRuntime>();
services.TryAddSingleton<IGrainRuntime, GrainRuntime>();
services.TryAddSingleton<OrleansTaskScheduler>();
services.TryAddSingleton<GrainFactory>(sp => sp.GetService<InsideRuntimeClient>().ConcreteGrainFactory);
services.TryAddExisting<IGrainFactory, GrainFactory>();
services.TryAddExisting<IInternalGrainFactory, GrainFactory>();
services.TryAddSingleton<TypeMetadataCache>();
services.TryAddSingleton<AssemblyProcessor>();
services.TryAddSingleton<ActivationDirectory>();
services.TryAddSingleton<LocalGrainDirectory>();
services.TryAddExisting<ILocalGrainDirectory, LocalGrainDirectory>();
services.TryAddSingleton<SiloStatisticsManager>();
services.TryAddSingleton<ISiloPerformanceMetrics>(sp => sp.GetRequiredService<SiloStatisticsManager>().MetricsTable);
services.TryAddSingleton<SiloAssemblyLoader>();
services.TryAddSingleton<GrainTypeManager>();
services.TryAddExisting<IMessagingConfiguration, GlobalConfiguration>();
services.TryAddSingleton<MessageCenter>();
services.TryAddExisting<IMessageCenter, MessageCenter>();
services.TryAddExisting<ISiloMessageCenter, MessageCenter>();
services.TryAddSingleton<Catalog>();
services.TryAddSingleton(sp => sp.GetRequiredService<Catalog>().Dispatcher);
services.TryAddSingleton<InsideRuntimeClient>();
services.TryAddExisting<IRuntimeClient, InsideRuntimeClient>();
services.TryAddExisting<ISiloRuntimeClient, InsideRuntimeClient>();
services.TryAddSingleton<MembershipFactory>();
services.TryAddSingleton<MultiClusterOracleFactory>();
services.TryAddSingleton<LocalReminderServiceFactory>();
services.TryAddSingleton<DeploymentLoadPublisher>();
services.TryAddSingleton<IMembershipTable>(
sp => sp.GetRequiredService<MembershipFactory>().GetMembershipTable(sp.GetRequiredService<GlobalConfiguration>()));
services.TryAddSingleton<MembershipOracle>(
sp =>
sp.GetRequiredService<MembershipFactory>()
.CreateMembershipOracle(sp.GetRequiredService<Silo>(), sp.GetRequiredService<IMembershipTable>()));
services.TryAddExisting<IMembershipOracle, MembershipOracle>();
services.TryAddExisting<ISiloStatusOracle, MembershipOracle>();
services.TryAddSingleton<Func<ISiloStatusOracle>>(sp => () => sp.GetRequiredService<ISiloStatusOracle>());
services.TryAddSingleton<MultiClusterOracleFactory>();
services.TryAddSingleton<LocalReminderServiceFactory>();
services.TryAddSingleton<ClientObserverRegistrar>();
services.TryAddSingleton<SiloProviderRuntime>();
services.TryAddExisting<IStreamProviderRuntime, SiloProviderRuntime>();
services.TryAddSingleton<ImplicitStreamSubscriberTable>();
// Placement
services.TryAddSingleton<PlacementDirectorsManager>();
services.TryAddSingleton<IPlacementDirector<RandomPlacement>, RandomPlacementDirector>();
services.TryAddSingleton<IPlacementDirector<PreferLocalPlacement>, PreferLocalPlacementDirector>();
services.TryAddSingleton<IPlacementDirector<StatelessWorkerPlacement>, StatelessWorkerDirector>();
services.TryAddSingleton<IPlacementDirector<ActivationCountBasedPlacement>, ActivationCountPlacementDirector>();
services.TryAddSingleton<DefaultPlacementStrategy>();
services.TryAddSingleton<ClientObserversPlacementDirector>();
services.TryAddSingleton<Func<IGrainRuntime>>(sp => () => sp.GetRequiredService<IGrainRuntime>());
services.TryAddSingleton<GrainCreator>();
if (initializationParams.GlobalConfig.UseVirtualBucketsConsistentRing)
{
services.TryAddSingleton<IConsistentRingProvider>(
sp =>
new VirtualBucketsRingProvider(
this.initializationParams.SiloAddress,
this.initializationParams.GlobalConfig.NumVirtualBucketsConsistentRing));
}
else
{
services.TryAddSingleton<IConsistentRingProvider>(
sp => new ConsistentRingProvider(this.initializationParams.SiloAddress));
}
});
this.assemblyProcessor = this.Services.GetRequiredService<AssemblyProcessor>();
this.assemblyProcessor.Initialize();
BufferPool.InitGlobalBufferPool(GlobalConfig);
UnobservedExceptionsHandlerClass.SetUnobservedExceptionHandler(UnobservedExceptionHandler);
AppDomain.CurrentDomain.UnhandledException += this.DomainUnobservedExceptionHandler;
try
{
grainFactory = Services.GetRequiredService<GrainFactory>();
}
catch (InvalidOperationException exc)
{
logger.Error(ErrorCode.SiloStartError, "Exception during Silo.Start, GrainFactory was not registered in Dependency Injection container", exc);
throw;
}
grainTypeManager = Services.GetRequiredService<GrainTypeManager>();
// Performance metrics
siloStatistics = Services.GetRequiredService<SiloStatisticsManager>();
// The scheduler
scheduler = Services.GetRequiredService<OrleansTaskScheduler>();
healthCheckParticipants.Add(scheduler);
runtimeClient = Services.GetRequiredService<InsideRuntimeClient>();
// Initialize the message center
messageCenter = Services.GetRequiredService<MessageCenter>();
messageCenter.RerouteHandler = runtimeClient.RerouteMessage;
messageCenter.SniffIncomingMessage = runtimeClient.SniffIncomingMessage;
// GrainRuntime can be created only here, after messageCenter was created.
grainRuntime = Services.GetRequiredService<IGrainRuntime>();
// 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 = Services.GetRequiredService<LocalGrainDirectory>();
// Now the activation directory.
activationDirectory = Services.GetRequiredService<ActivationDirectory>();
// Now the consistent ring provider
RingProvider = Services.GetRequiredService<IConsistentRingProvider>();
// to preserve backwards compatibility, only use the service provider to inject grain dependencies if the user supplied his own
// service provider, meaning that he is explicitly opting into it.
catalog = Services.GetRequiredService<Catalog>();
siloStatistics.MetricsTable.Scheduler = scheduler;
siloStatistics.MetricsTable.ActivationDirectory = activationDirectory;
siloStatistics.MetricsTable.ActivationCollector = catalog.ActivationCollector;
siloStatistics.MetricsTable.MessageCenter = messageCenter;
// Now the incoming message agents
incomingSystemAgent = new IncomingMessageAgent(Message.Categories.System, messageCenter, activationDirectory, scheduler, catalog.Dispatcher);
incomingPingAgent = new IncomingMessageAgent(Message.Categories.Ping, messageCenter, activationDirectory, scheduler, catalog.Dispatcher);
incomingAgent = new IncomingMessageAgent(Message.Categories.Application, messageCenter, activationDirectory, scheduler, catalog.Dispatcher);
membershipFactory = Services.GetRequiredService<MembershipFactory>();
membershipOracle = Services.GetRequiredService<IMembershipOracle>();
SystemStatus.Current = SystemStatus.Created;
StringValueStatistic.FindOrCreate(StatisticNames.SILO_START_TIME,
() => LogFormatter.PrintDate(startTime)); // this will help troubleshoot production deployment when looking at MDS logs.
logger.Info(ErrorCode.SiloInitializingFinished, "-------------- Started silo {0}, ConsistentHashCode {1:X} --------------", SiloAddress.ToLongString(), SiloAddress.GetConsistentHashCode());
}
