/// <summary> /// TBD /// </summary> /// <param name="role">TBD</param> /// <param name="rememberEntities">TBD</param> /// <param name="journalPluginId">TBD</param> /// <param name="snapshotPluginId">TBD</param> /// <param name="passivateIdleEntityAfter">TBD</param> /// <param name="stateStoreMode">TBD</param> /// <param name="tuningParameters">TBD</param> /// <param name="coordinatorSingletonSettings">TBD</param> /// <param name="leaseSettings">TBD</param> public ClusterShardingSettings( string role, bool rememberEntities, string journalPluginId, string snapshotPluginId, TimeSpan passivateIdleEntityAfter, StateStoreMode stateStoreMode, TuningParameters tuningParameters, ClusterSingletonManagerSettings coordinatorSingletonSettings, LeaseUsageSettings leaseSettings) { Role = role; RememberEntities = rememberEntities; JournalPluginId = journalPluginId; SnapshotPluginId = snapshotPluginId; PassivateIdleEntityAfter = passivateIdleEntityAfter; StateStoreMode = stateStoreMode; TuningParameters = tuningParameters; CoordinatorSingletonSettings = coordinatorSingletonSettings; LeaseSettings = leaseSettings; }
/// <summary> /// Creates a new instance of the <see cref="ClusterSingletonManagerSettings"/>. /// </summary> /// <param name="singletonName">The actor name of the child singleton actor.</param> /// <param name="role"> /// Singleton among the nodes tagged with specified role. If the role is not specified /// it's a singleton among all nodes in the cluster. /// </param> /// <param name="removalMargin"> /// Margin until the singleton instance that belonged to a downed/removed partition is /// created in surviving partition. The purpose of this margin is that in case of /// a network partition the singleton actors in the non-surviving partitions must /// be stopped before corresponding actors are started somewhere else. /// This is especially important for persistent actors. /// </param> /// <param name="handOverRetryInterval"> /// When a node is becoming oldest it sends hand-over /// request to previous oldest, that might be leaving the cluster. This is /// retried with this interval until the previous oldest confirms that the hand /// over has started or the previous oldest member is removed from the cluster /// (+ <paramref name="removalMargin"/>). /// </param> /// <param name="leaseSettings">LeaseSettings for acquiring before creating the singleton actor</param> /// <exception cref="ArgumentException">TBD</exception> public ClusterSingletonManagerSettings(string singletonName, string role, TimeSpan removalMargin, TimeSpan handOverRetryInterval, LeaseUsageSettings leaseSettings) { if (string.IsNullOrWhiteSpace(singletonName)) { throw new ArgumentNullException(nameof(singletonName)); } if (removalMargin < TimeSpan.Zero) { throw new ArgumentException("ClusterSingletonManagerSettings.RemovalMargin must be positive", nameof(removalMargin)); } if (handOverRetryInterval <= TimeSpan.Zero) { throw new ArgumentException("ClusterSingletonManagerSettings.HandOverRetryInterval must be positive", nameof(handOverRetryInterval)); } SingletonName = singletonName; Role = role; RemovalMargin = removalMargin; HandOverRetryInterval = handOverRetryInterval; LeaseSettings = leaseSettings; }
/// <summary> /// Creates a new <see cref="ClusterSingletonManagerSettings"/> instance. /// </summary> /// <param name="config">The HOCON configuration used to create the settings.</param> /// <returns>The requested settings.</returns> public static ClusterSingletonManagerSettings Create(Config config) { if (config.IsNullOrEmpty()) { throw ConfigurationException.NullOrEmptyConfig <ClusterSingletonManagerSettings>(); } LeaseUsageSettings lease = null; var leaseConfigPath = config.GetString("use-lease"); if (!string.IsNullOrEmpty(leaseConfigPath)) { lease = new LeaseUsageSettings(leaseConfigPath, config.GetTimeSpan("lease-retry-interval")); } return(new ClusterSingletonManagerSettings( singletonName: config.GetString("singleton-name"), role: RoleOption(config.GetString("role")), removalMargin: TimeSpan.Zero, // defaults to ClusterSettings.DownRemovalMargin handOverRetryInterval: config.GetTimeSpan("hand-over-retry-interval"), leaseSettings: lease)); }
public ClusterShardingSettings WithLeaseSettings(LeaseUsageSettings leaseSettings) { return(Copy(leaseSettings: leaseSettings)); }
/// <summary> /// TBD /// </summary> /// <param name="config">TBD</param> /// <param name="singletonConfig">TBD</param> /// <returns>TBD</returns> public static ClusterShardingSettings Create(Config config, Config singletonConfig) { if (config.IsNullOrEmpty()) { throw ConfigurationException.NullOrEmptyConfig <ClusterShardingSettings>(); } var tuningParameters = new TuningParameters( coordinatorFailureBackoff: config.GetTimeSpan("coordinator-failure-backoff"), retryInterval: config.GetTimeSpan("retry-interval"), bufferSize: config.GetInt("buffer-size"), handOffTimeout: config.GetTimeSpan("handoff-timeout"), shardStartTimeout: config.GetTimeSpan("shard-start-timeout"), shardFailureBackoff: config.GetTimeSpan("shard-failure-backoff"), entityRestartBackoff: config.GetTimeSpan("entity-restart-backoff"), rebalanceInterval: config.GetTimeSpan("rebalance-interval"), snapshotAfter: config.GetInt("snapshot-after"), keepNrOfBatches: config.GetInt("keep-nr-of-batches"), leastShardAllocationRebalanceThreshold: config.GetInt("least-shard-allocation-strategy.rebalance-threshold"), leastShardAllocationMaxSimultaneousRebalance: config.GetInt("least-shard-allocation-strategy.max-simultaneous-rebalance"), waitingForStateTimeout: config.GetTimeSpan("waiting-for-state-timeout"), updatingStateTimeout: config.GetTimeSpan("updating-state-timeout"), entityRecoveryStrategy: config.GetString("entity-recovery-strategy"), entityRecoveryConstantRateStrategyFrequency: config.GetTimeSpan("entity-recovery-constant-rate-strategy.frequency"), entityRecoveryConstantRateStrategyNumberOfEntities: config.GetInt("entity-recovery-constant-rate-strategy.number-of-entities"), leastShardAllocationAbsoluteLimit: config.GetInt("least-shard-allocation-strategy.rebalance-absolute-limit"), leastShardAllocationRelativeLimit: config.GetDouble("least-shard-allocation-strategy.rebalance-relative-limit")); var coordinatorSingletonSettings = ClusterSingletonManagerSettings.Create(singletonConfig); var role = config.GetString("role", null); if (role == string.Empty) { role = null; } var usePassivateIdle = config.GetString("passivate-idle-entity-after").ToLowerInvariant(); var passivateIdleAfter = usePassivateIdle.Equals("off") || usePassivateIdle.Equals("false") || usePassivateIdle.Equals("no") ? TimeSpan.Zero : config.GetTimeSpan("passivate-idle-entity-after"); LeaseUsageSettings lease = null; var leaseConfigPath = config.GetString("use-lease"); if (!string.IsNullOrEmpty(leaseConfigPath)) { lease = new LeaseUsageSettings(leaseConfigPath, config.GetTimeSpan("lease-retry-interval")); } return(new ClusterShardingSettings( role: role, rememberEntities: config.GetBoolean("remember-entities"), journalPluginId: config.GetString("journal-plugin-id"), snapshotPluginId: config.GetString("snapshot-plugin-id"), passivateIdleEntityAfter: passivateIdleAfter, stateStoreMode: (StateStoreMode)Enum.Parse(typeof(StateStoreMode), config.GetString("state-store-mode"), ignoreCase: true), tuningParameters: tuningParameters, coordinatorSingletonSettings: coordinatorSingletonSettings, leaseSettings: lease)); }
/// <summary> /// Create a singleton manager with specified singleton lease settings. /// </summary> /// <param name="leaseSettings">TBD</param> /// <returns></returns> public ClusterSingletonManagerSettings WithLeaseSettings(LeaseUsageSettings leaseSettings) { return(Copy(leaseSettings: leaseSettings)); }