internal SchedulingContext(SystemTarget systemTarget, bool lowPrioritySystemTarget) { SystemTarget = systemTarget; ContextType = SchedulingContextType.SystemTarget; isLowPrioritySystemTarget = lowPrioritySystemTarget; IsReactiveComputation = false; }
public Merger(SystemTarget target, bool isTestMode) { _target = target; _rootFolderPath = !isTestMode ? FilePaths.GenerateXamlSearchFolderPath() : FilePaths.GetExecutingAssemblyFilePath(); }
public static string GenerateGenericFilePath(SystemTarget target) { return Path.Combine( BaseFolderPath, Constants.ControlFolder + "." + SystemTargets.GetSystemTargetPath(target).Replace(" ", ""), Constants.ThemesFolder, Constants.GenericThemeXaml); }
public static string GenerateGenericFilePath(SystemTarget target) { return(Path.Combine( BaseFolderPath, Constants.ControlFolder + "." + SystemTargets.GetSystemTargetPath(target).Replace(" ", ""), Constants.ThemesFolder, Constants.GenericThemeXaml)); }
public static string GetSystemTargetPath(SystemTarget target) { switch (target) { case SystemTarget.WindowsPhone7: return Constants.WindowsPhone7; case SystemTarget.WindowsPhone8: return Constants.WindowsPhone8; case SystemTarget.WindowsStore: return Constants.WindowsStore; default: return null; } }
public string DetailedStatus() { switch (ContextType) { case SchedulingContextType.Activation: return(Activation.ToDetailedString(true)); case SchedulingContextType.SystemTarget: return(SystemTarget.ToDetailedString()); case SchedulingContextType.SystemThread: return(String.Format("DispatcherTarget{0}", DispatcherTarget)); default: return(ContextType.ToString()); } }
public static string GetSystemTargetPath(SystemTarget target) { switch (target) { case SystemTarget.WindowsPhone7: return(Constants.WindowsPhone7); case SystemTarget.WindowsPhone8: return(Constants.WindowsPhone8); case SystemTarget.WindowsStore: return(Constants.WindowsStore); default: return(null); } }
public override string ToString() { switch (ContextType) { case SchedulingContextType.Activation: return(Activation.ToString()); case SchedulingContextType.SystemTarget: return(SystemTarget.ToString()); case SchedulingContextType.SystemThread: return(String.Format("DispatcherTarget{0}", DispatcherTarget)); default: return(ContextType.ToString()); } }
private static string GetFileTypeByTarget(SystemTarget target) { switch (target) { case SystemTarget.WindowsPhone: return(Constants.WindowsPhoneEndFileName); case SystemTarget.WindowsPhone7: return(Constants.WindowsPhone7EndFileName); case SystemTarget.WindowsPhone8: return(Constants.WindowsPhone8EndFileName); case SystemTarget.WindowsStore: return(Constants.WindowsStoreEndFileName); } throw new ArgumentOutOfRangeException("target", target, "cannot find target"); }
private bool AreSame(object obj) { var other = obj as SchedulingContext; switch (ContextType) { case SchedulingContextType.Activation: return(other != null && Activation.Equals(other.Activation)); case SchedulingContextType.SystemTarget: return(other != null && SystemTarget.Equals(other.SystemTarget)); case SchedulingContextType.SystemThread: return(other != null && DispatcherTarget.Equals(other.DispatcherTarget)); default: return(false); } }
internal SchedulingContext(SystemTarget systemTarget, bool lowPrioritySystemTarget) { SystemTarget = systemTarget; ContextType = SchedulingContextType.SystemTarget; isLowPrioritySystemTarget = lowPrioritySystemTarget; }
public ResponseWorkItem(SystemTarget t, Message m) { target = t; response = m; }
public static IServiceCollection AddLegacyClusterConfigurationSupport(this IServiceCollection services, ClusterConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } if (services.Any(service => service.ServiceType == typeof(ClusterConfiguration))) { throw new InvalidOperationException("Cannot configure legacy ClusterConfiguration support twice"); } // these will eventually be removed once our code doesn't depend on the old ClientConfiguration services.AddSingleton(configuration); services.TryAddSingleton <LegacyConfigurationWrapper>(); services.TryAddSingleton(sp => sp.GetRequiredService <LegacyConfigurationWrapper>().ClusterConfig.Globals); services.TryAddTransient(sp => sp.GetRequiredService <LegacyConfigurationWrapper>().NodeConfig); services.TryAddSingleton <Factory <NodeConfiguration> >( sp => { var initializationParams = sp.GetRequiredService <LegacyConfigurationWrapper>(); return(() => initializationParams.NodeConfig); }); services.Configure <SiloOptions>(options => { if (string.IsNullOrWhiteSpace(options.ClusterId) && !string.IsNullOrWhiteSpace(configuration.Globals.ClusterId)) { options.ClusterId = configuration.Globals.ClusterId; } if (options.ServiceId == Guid.Empty) { options.ServiceId = configuration.Globals.ServiceId; } }); services.Configure <MultiClusterOptions>(options => { var globals = configuration.Globals; if (globals.HasMultiClusterNetwork) { options.HasMultiClusterNetwork = true; options.BackgroundGossipInterval = globals.BackgroundGossipInterval; options.DefaultMultiCluster = globals.DefaultMultiCluster?.ToList(); options.GlobalSingleInstanceNumberRetries = globals.GlobalSingleInstanceNumberRetries; options.GlobalSingleInstanceRetryInterval = globals.GlobalSingleInstanceRetryInterval; options.MaxMultiClusterGateways = globals.MaxMultiClusterGateways; options.UseGlobalSingleInstanceByDefault = globals.UseGlobalSingleInstanceByDefault; } }); services.TryAddFromExisting <IMessagingConfiguration, GlobalConfiguration>(); services.AddOptions <StatisticsOptions>() .Configure <NodeConfiguration>((options, nodeConfig) => LegacyConfigurationExtensions.CopyStatisticsOptions(nodeConfig, options)); // Translate legacy configuration to new Options services.Configure <SiloMessagingOptions>(options => { LegacyConfigurationExtensions.CopyCommonMessagingOptions(configuration.Globals, options); options.SiloSenderQueues = configuration.Globals.SiloSenderQueues; options.GatewaySenderQueues = configuration.Globals.GatewaySenderQueues; options.MaxForwardCount = configuration.Globals.MaxForwardCount; options.ClientDropTimeout = configuration.Globals.ClientDropTimeout; }); services.Configure <NetworkingOptions>(options => LegacyConfigurationExtensions.CopyNetworkingOptions(configuration.Globals, options)); services.AddOptions <EndpointOptions>() .Configure <IOptions <SiloOptions> >((options, siloOptions) => { var nodeConfig = configuration.GetOrCreateNodeConfigurationForSilo(siloOptions.Value.SiloName); if (options.IPAddress == null && string.IsNullOrWhiteSpace(options.HostNameOrIPAddress)) { options.IPAddress = nodeConfig.Endpoint.Address; options.Port = nodeConfig.Endpoint.Port; } if (options.ProxyPort == 0 && nodeConfig.ProxyGatewayEndpoint != null) { options.ProxyPort = nodeConfig.ProxyGatewayEndpoint.Port; } }); services.Configure <SerializationProviderOptions>(options => { options.SerializationProviders = configuration.Globals.SerializationProviders; options.FallbackSerializationProvider = configuration.Globals.FallbackSerializationProvider; }); services.AddOptions <GrainClassOptions>().Configure <IOptions <SiloOptions> >((options, siloOptions) => { var nodeConfig = configuration.GetOrCreateNodeConfigurationForSilo(siloOptions.Value.SiloName); options.ExcludedGrainTypes.AddRange(nodeConfig.ExcludedGrainTypes); }); LegacyMembershipConfigurator.ConfigureServices(configuration.Globals, services); services.AddOptions <SchedulingOptions>().Configure <GlobalConfiguration>((options, config) => { options.AllowCallChainReentrancy = config.AllowCallChainReentrancy; options.PerformDeadlockDetection = config.PerformDeadlockDetection; }); services.TryAddSingleton <LegacyProviderConfigurator.ScheduleTask>(sp => { OrleansTaskScheduler scheduler = sp.GetRequiredService <OrleansTaskScheduler>(); SystemTarget fallbackSystemTarget = sp.GetRequiredService <FallbackSystemTarget>(); return((taskFunc) => scheduler.QueueTask(taskFunc, fallbackSystemTarget.SchedulingContext)); }); LegacyProviderConfigurator <ISiloLifecycle> .ConfigureServices(configuration.Globals.ProviderConfigurations, services, SiloDefaultProviderInitStage, SiloDefaultProviderStartStage); return(services); }
public static string GenerateGenericFilePath(SystemTarget target) { return Path.Combine(BaseFilePath, SystemTargets.GetSystemTargetPath(target), Constants.GenericThemeFile); }
public void ReceiveMessage(Message msg) { this.messagingTrace.OnIncomingMessageAgentReceiveMessage(msg); ISchedulingContext context; // Find the activation it targets; first check for a system activation, then an app activation if (msg.TargetGrain.IsSystemTarget) { SystemTarget target = this.directory.FindSystemTarget(msg.TargetActivation); if (target == null) { MessagingStatisticsGroup.OnRejectedMessage(msg); Message response = this.messageFactory.CreateRejectionResponse(msg, Message.RejectionTypes.Unrecoverable, string.Format("SystemTarget {0} not active on this silo. Msg={1}", msg.TargetGrain, msg)); this.messageCenter.SendMessage(response); this.log.Warn(ErrorCode.MessagingMessageFromUnknownActivation, "Received a message {0} for an unknown SystemTarget: {1}", msg, msg.TargetAddress); return; } context = target.SchedulingContext; switch (msg.Direction) { case Message.Directions.Request: this.messagingTrace.OnEnqueueMessageOnActivation(msg, context); this.scheduler.QueueWorkItem(new RequestWorkItem(target, msg), context); break; case Message.Directions.Response: this.messagingTrace.OnEnqueueMessageOnActivation(msg, context); this.scheduler.QueueWorkItem(new ResponseWorkItem(target, msg), context); break; default: this.log.Error(ErrorCode.Runtime_Error_100097, "Invalid message: " + msg); break; } } else { // Run this code on the target activation's context, if it already exists ActivationData targetActivation = this.directory.FindTarget(msg.TargetActivation); if (targetActivation != null) { lock (targetActivation) { var target = targetActivation; // to avoid a warning about nulling targetActivation under a lock on it if (target.State == ActivationState.Valid) { // Response messages are not subject to overload checks. if (msg.Direction != Message.Directions.Response) { var overloadException = target.CheckOverloaded(this.log); if (overloadException != null) { // Send rejection as soon as we can, to avoid creating additional work for runtime this.dispatcher.RejectMessage(msg, Message.RejectionTypes.Overloaded, overloadException, "Target activation is overloaded " + target); return; } } // Run ReceiveMessage in context of target activation context = target.SchedulingContext; } else { // Can't use this activation - will queue for another activation target = null; context = null; } EnqueueReceiveMessage(msg, target, context); } } else { // No usable target activation currently, so run ReceiveMessage in system context EnqueueReceiveMessage(msg, null, null); } } void EnqueueReceiveMessage(Message msg, ActivationData targetActivation, ISchedulingContext context) { this.messagingTrace.OnEnqueueMessageOnActivation(msg, context); targetActivation?.IncrementEnqueuedOnDispatcherCount(); scheduler.QueueWorkItem(new ClosureWorkItem(() => { try { dispatcher.ReceiveMessage(msg); } finally { targetActivation?.DecrementEnqueuedOnDispatcherCount(); } }, "Dispatcher.ReceiveMessage"), context); } }
public RequestWorkItem(SystemTarget t, Message m) { target = t; request = m; }
private static string GetFileTypeByTarget(SystemTarget target) { switch (target) { case SystemTarget.WindowsPhone: return Constants.WindowsPhoneEndFileName; case SystemTarget.WindowsPhone7: return Constants.WindowsPhone7EndFileName; case SystemTarget.WindowsPhone8: return Constants.WindowsPhone8EndFileName; case SystemTarget.WindowsStore: return Constants.WindowsStoreEndFileName; } throw new ArgumentOutOfRangeException("target", target, "cannot find target"); }
private void ReceiveMessage(Message msg) { MessagingProcessingStatisticsGroup.OnImaMessageReceived(msg); ISchedulingContext context; // Find the activation it targets; first check for a system activation, then an app activation if (msg.TargetGrain.IsSystemTarget) { SystemTarget target = directory.FindSystemTarget(msg.TargetActivation); if (target == null) { MessagingStatisticsGroup.OnRejectedMessage(msg); Message response = this.messageFactory.CreateRejectionResponse(msg, Message.RejectionTypes.Unrecoverable, String.Format("SystemTarget {0} not active on this silo. Msg={1}", msg.TargetGrain, msg)); messageCenter.SendMessage(response); Log.Warn(ErrorCode.MessagingMessageFromUnknownActivation, "Received a message {0} for an unknown SystemTarget: {1}", msg, msg.TargetAddress); return; } context = target.SchedulingContext; switch (msg.Direction) { case Message.Directions.Request: MessagingProcessingStatisticsGroup.OnImaMessageEnqueued(context); scheduler.QueueWorkItem(new RequestWorkItem(target, msg), context); break; case Message.Directions.Response: MessagingProcessingStatisticsGroup.OnImaMessageEnqueued(context); scheduler.QueueWorkItem(new ResponseWorkItem(target, msg), context); break; default: Log.Error(ErrorCode.Runtime_Error_100097, "Invalid message: " + msg); break; } } else { // Run this code on the target activation's context, if it already exists ActivationData targetActivation = directory.FindTarget(msg.TargetActivation); if (targetActivation != null) { lock (targetActivation) { var target = targetActivation; // to avoid a warning about nulling targetActivation under a lock on it if (target.State == ActivationState.Valid) { var overloadException = target.CheckOverloaded(Log); if (overloadException != null) { // Send rejection as soon as we can, to avoid creating additional work for runtime dispatcher.RejectMessage(msg, Message.RejectionTypes.Overloaded, overloadException, "Target activation is overloaded " + target); return; } // Run ReceiveMessage in context of target activation context = new SchedulingContext(target); } else { // Can't use this activation - will queue for another activation target = null; context = null; } EnqueueReceiveMessage(msg, target, context); } } else { // No usable target activation currently, so run ReceiveMessage in system context EnqueueReceiveMessage(msg, null, null); } } }
public static IServiceCollection AddLegacyClusterConfigurationSupport(this IServiceCollection services, ClusterConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } if (services.TryGetClusterConfiguration() != null) { throw new InvalidOperationException("Cannot configure legacy ClusterConfiguration support twice"); } // these will eventually be removed once our code doesn't depend on the old ClientConfiguration services.AddSingleton(configuration); services.TryAddSingleton <LegacyConfigurationWrapper>(); services.TryAddSingleton(sp => sp.GetRequiredService <LegacyConfigurationWrapper>().ClusterConfig.Globals); services.TryAddTransient(sp => sp.GetRequiredService <LegacyConfigurationWrapper>().NodeConfig); services.TryAddSingleton <Factory <NodeConfiguration> >( sp => { var initializationParams = sp.GetRequiredService <LegacyConfigurationWrapper>(); return(() => initializationParams.NodeConfig); }); services.Configure <SiloOptions>(options => { if (string.IsNullOrWhiteSpace(options.ClusterId) && !string.IsNullOrWhiteSpace(configuration.Globals.ClusterId)) { options.ClusterId = configuration.Globals.ClusterId; } if (options.ServiceId == Guid.Empty) { options.ServiceId = configuration.Globals.ServiceId; } options.FastKillOnCancelKeyPress = configuration.Globals.FastKillOnCancelKeyPress; }); services.Configure <MultiClusterOptions>(options => { var globals = configuration.Globals; if (globals.HasMultiClusterNetwork) { options.HasMultiClusterNetwork = true; options.BackgroundGossipInterval = globals.BackgroundGossipInterval; options.DefaultMultiCluster = globals.DefaultMultiCluster?.ToList(); options.GlobalSingleInstanceNumberRetries = globals.GlobalSingleInstanceNumberRetries; options.GlobalSingleInstanceRetryInterval = globals.GlobalSingleInstanceRetryInterval; options.MaxMultiClusterGateways = globals.MaxMultiClusterGateways; options.UseGlobalSingleInstanceByDefault = globals.UseGlobalSingleInstanceByDefault; foreach (GlobalConfiguration.GossipChannelConfiguration channelConfig in globals.GossipChannels) { options.GossipChannels.Add(GlobalConfiguration.Remap(channelConfig.ChannelType), channelConfig.ConnectionString); } } }); services.TryAddFromExisting <IMessagingConfiguration, GlobalConfiguration>(); services.AddOptions <SiloStatisticsOptions>() .Configure <NodeConfiguration>((options, nodeConfig) => LegacyConfigurationExtensions.CopyStatisticsOptions(nodeConfig, options)) .Configure <GlobalConfiguration>((options, config) => { options.DeploymentLoadPublisherRefreshTime = config.DeploymentLoadPublisherRefreshTime; }); services.AddOptions <LoadSheddingOptions>() .Configure <NodeConfiguration>((options, nodeConfig) => { options.LoadSheddingEnabled = nodeConfig.LoadSheddingEnabled; options.LoadSheddingLimit = nodeConfig.LoadSheddingLimit; }); // Translate legacy configuration to new Options services.AddOptions <SiloMessagingOptions>() .Configure <GlobalConfiguration>((options, config) => { LegacyConfigurationExtensions.CopyCommonMessagingOptions(config, options); options.SiloSenderQueues = config.SiloSenderQueues; options.GatewaySenderQueues = config.GatewaySenderQueues; options.MaxForwardCount = config.MaxForwardCount; options.ClientDropTimeout = config.ClientDropTimeout; options.ClientRegistrationRefresh = config.ClientRegistrationRefresh; options.MaxRequestProcessingTime = config.MaxRequestProcessingTime; options.AssumeHomogenousSilosForTesting = config.AssumeHomogenousSilosForTesting; }) .Configure <NodeConfiguration>((options, config) => { options.PropagateActivityId = config.PropagateActivityId; LimitValue requestLimit = config.LimitManager.GetLimit(LimitNames.LIMIT_MAX_ENQUEUED_REQUESTS); options.MaxEnqueuedRequestsSoftLimit = requestLimit.SoftLimitThreshold; options.MaxEnqueuedRequestsHardLimit = requestLimit.HardLimitThreshold; LimitValue statelessWorkerRequestLimit = config.LimitManager.GetLimit(LimitNames.LIMIT_MAX_ENQUEUED_REQUESTS_STATELESS_WORKER); options.MaxEnqueuedRequestsSoftLimit_StatelessWorker = statelessWorkerRequestLimit.SoftLimitThreshold; options.MaxEnqueuedRequestsHardLimit_StatelessWorker = statelessWorkerRequestLimit.HardLimitThreshold; }); services.Configure <NetworkingOptions>(options => LegacyConfigurationExtensions.CopyNetworkingOptions(configuration.Globals, options)); services.AddOptions <EndpointOptions>() .Configure <IOptions <SiloOptions> >((options, siloOptions) => { var nodeConfig = configuration.GetOrCreateNodeConfigurationForSilo(siloOptions.Value.SiloName); if (options.IPAddress == null && string.IsNullOrWhiteSpace(options.HostNameOrIPAddress)) { options.IPAddress = nodeConfig.Endpoint.Address; options.Port = nodeConfig.Endpoint.Port; } if (options.ProxyPort == 0 && nodeConfig.ProxyGatewayEndpoint != null) { options.ProxyPort = nodeConfig.ProxyGatewayEndpoint.Port; } }); services.Configure <SerializationProviderOptions>(options => { options.SerializationProviders = configuration.Globals.SerializationProviders; options.FallbackSerializationProvider = configuration.Globals.FallbackSerializationProvider; }); services.Configure <TelemetryOptions>(options => { LegacyConfigurationExtensions.CopyTelemetryOptions(configuration.Defaults.TelemetryConfiguration, services, options); }); services.AddOptions <GrainClassOptions>().Configure <IOptions <SiloOptions> >((options, siloOptions) => { var nodeConfig = configuration.GetOrCreateNodeConfigurationForSilo(siloOptions.Value.SiloName); options.ExcludedGrainTypes.AddRange(nodeConfig.ExcludedGrainTypes); }); LegacyMembershipConfigurator.ConfigureServices(configuration.Globals, services); services.AddOptions <SchedulingOptions>() .Configure <GlobalConfiguration>((options, config) => { options.AllowCallChainReentrancy = config.AllowCallChainReentrancy; options.PerformDeadlockDetection = config.PerformDeadlockDetection; }) .Configure <NodeConfiguration>((options, nodeConfig) => { options.MaxActiveThreads = nodeConfig.MaxActiveThreads; options.DelayWarningThreshold = nodeConfig.DelayWarningThreshold; options.ActivationSchedulingQuantum = nodeConfig.ActivationSchedulingQuantum; options.TurnWarningLengthThreshold = nodeConfig.TurnWarningLengthThreshold; options.EnableWorkerThreadInjection = nodeConfig.EnableWorkerThreadInjection; LimitValue itemLimit = nodeConfig.LimitManager.GetLimit(LimitNames.LIMIT_MAX_PENDING_ITEMS); options.MaxPendingWorkItemsSoftLimit = itemLimit.SoftLimitThreshold; options.MaxPendingWorkItemsHardLimit = itemLimit.HardLimitThreshold; }); services.AddOptions <GrainCollectionOptions>().Configure <GlobalConfiguration>((options, config) => { options.CollectionQuantum = config.CollectionQuantum; options.CollectionAge = config.Application.DefaultCollectionAgeLimit; foreach (GrainTypeConfiguration grainConfig in config.Application.ClassSpecific) { if (grainConfig.CollectionAgeLimit.HasValue) { options.ClassSpecificCollectionAge.Add(grainConfig.FullTypeName, grainConfig.CollectionAgeLimit.Value); } } ; }); services.TryAddSingleton <LegacyProviderConfigurator.ScheduleTask>(sp => { OrleansTaskScheduler scheduler = sp.GetRequiredService <OrleansTaskScheduler>(); SystemTarget fallbackSystemTarget = sp.GetRequiredService <FallbackSystemTarget>(); return((taskFunc) => scheduler.QueueTask(taskFunc, fallbackSystemTarget.SchedulingContext)); }); LegacyProviderConfigurator <ISiloLifecycle> .ConfigureServices(configuration.Globals.ProviderConfigurations, services, SiloDefaultProviderInitStage, SiloDefaultProviderStartStage); services.AddOptions <GrainPlacementOptions>().Configure <GlobalConfiguration>((options, config) => { options.DefaultPlacementStrategy = config.DefaultPlacementStrategy; options.ActivationCountPlacementChooseOutOf = config.ActivationCountBasedPlacementChooseOutOf; }); services.AddOptions <StaticClusterDeploymentOptions>().Configure <ClusterConfiguration>((options, config) => { options.SiloNames = config.Overrides.Keys.ToList(); }); // add grain service configs as keyed services short id = 0; foreach (IGrainServiceConfiguration grainServiceConfiguration in configuration.Globals.GrainServiceConfigurations.GrainServices.Values) { services.AddSingletonKeyedService <long, IGrainServiceConfiguration>(id++, (sp, k) => grainServiceConfiguration); } // populate grain service options id = 0; services.AddOptions <GrainServiceOptions>().Configure <GlobalConfiguration>((options, config) => { foreach (IGrainServiceConfiguration grainServiceConfiguration in config.GrainServiceConfigurations.GrainServices.Values) { options.GrainServices.Add(new KeyValuePair <string, short>(grainServiceConfiguration.ServiceType, id++)); } }); services.AddOptions <ConsistentRingOptions>().Configure <GlobalConfiguration>((options, config) => { options.UseVirtualBucketsConsistentRing = config.UseVirtualBucketsConsistentRing; options.NumVirtualBucketsConsistentRing = config.NumVirtualBucketsConsistentRing; }); services.AddOptions <MembershipOptions>() .Configure <GlobalConfiguration>((options, config) => { options.NumMissedTableIAmAliveLimit = config.NumMissedTableIAmAliveLimit; options.LivenessEnabled = config.LivenessEnabled; options.ProbeTimeout = config.ProbeTimeout; options.TableRefreshTimeout = config.TableRefreshTimeout; options.DeathVoteExpirationTimeout = config.DeathVoteExpirationTimeout; options.IAmAliveTablePublishTimeout = config.IAmAliveTablePublishTimeout; options.MaxJoinAttemptTime = config.MaxJoinAttemptTime; options.ExpectedClusterSize = config.ExpectedClusterSize; options.ValidateInitialConnectivity = config.ValidateInitialConnectivity; options.NumMissedProbesLimit = config.NumMissedProbesLimit; options.UseLivenessGossip = config.UseLivenessGossip; options.NumProbedSilos = config.NumProbedSilos; options.NumVotesForDeathDeclaration = config.NumVotesForDeathDeclaration; }) .Configure <ClusterConfiguration>((options, config) => { options.IsRunningAsUnitTest = config.IsRunningAsUnitTest; }); services.AddOptions <ReminderOptions>() .Configure <GlobalConfiguration>((options, config) => { options.ReminderService = GlobalConfiguration.Remap(config.ReminderServiceType); options.ReminderTableAssembly = config.ReminderTableAssembly; options.UseMockReminderTable = config.UseMockReminderTable; options.MockReminderTableTimeout = config.MockReminderTableTimeout; }); services.AddOptions <GrainVersioningOptions>() .Configure <GlobalConfiguration>((options, config) => { options.DefaultCompatibilityStrategy = config.DefaultCompatibilityStrategy?.GetType().Name ?? GrainVersioningOptions.DEFAULT_COMPATABILITY_STRATEGY; options.DefaultVersionSelectorStrategy = config.DefaultVersionSelectorStrategy?.GetType().Name ?? GrainVersioningOptions.DEFAULT_VERSION_SELECTOR_STRATEGY; }); services.AddOptions <ThreadPoolOptions>() .Configure <NodeConfiguration>((options, config) => { options.MinDotNetThreadPoolSize = config.MinDotNetThreadPoolSize; }); services.AddOptions <ServicePointOptions>() .Configure <NodeConfiguration>((options, config) => { options.DefaultConnectionLimit = config.DefaultConnectionLimit; options.Expect100Continue = config.Expect100Continue; options.UseNagleAlgorithm = config.UseNagleAlgorithm; }); services.AddOptions <StorageOptions>() .Configure <GlobalConfiguration>((options, config) => { options.DataConnectionString = config.DataConnectionString; options.DataConnectionStringForReminders = config.DataConnectionStringForReminders; }); services.AddOptions <AdoNetOptions>() .Configure <GlobalConfiguration>((options, config) => { options.Invariant = config.AdoInvariant; options.InvariantForReminders = config.AdoInvariantForReminders; }); services.AddOptions <TypeManagementOptions>() .Configure <GlobalConfiguration>((options, config) => { options.TypeMapRefreshInterval = config.TypeMapRefreshInterval; }); services.AddOptions <GrainDirectoryOptions>() .Configure <GlobalConfiguration>((options, config) => { options.CachingStrategy = GlobalConfiguration.Remap(config.DirectoryCachingStrategy); options.CacheSize = config.CacheSize; options.InitialCacheTTL = config.InitialCacheTTL; options.MaximumCacheTTL = config.MaximumCacheTTL; options.CacheTTLExtensionFactor = config.CacheTTLExtensionFactor; options.LazyDeregistrationDelay = config.DirectoryLazyDeregistrationDelay; }); return(services); }