コード例 #1
0
 private ReliableStateManagerConfiguration(
     ReliableStateManagerReplicatorSettings replicatorSettings,
     string configPackageName,
     string replicatorSecuritySectionName,
     string replicatorSettingsSectionName,
     Func<Task> onInitializeStateSerializersEvent)
 {
     this.ReplicatorSettings = replicatorSettings;
     this.ConfigPackageName = configPackageName;
     this.ReplicatorSecuritySectionName = replicatorSecuritySectionName;
     this.ReplicatorSettingsSectionName = replicatorSettingsSectionName;
     this.OnInitializeStateSerializersEvent = onInitializeStateSerializersEvent ?? (() => Task.FromResult(true));
 }
コード例 #2
0
        /// <summary>
        /// Checks for equality of setting values.
        /// </summary>
        /// <param name="old">Old settings.</param>
        /// <param name="updated">Updated settings.</param>
        /// <returns>
        /// TRUE if the settings are equivalent.
        /// </returns>
        private static bool InternalEquals(ReliableStateManagerReplicatorSettings old, ReliableStateManagerReplicatorSettings updated)
        {
            // compare only the V2 settings.
            var areEqual = true;

            if (!string.IsNullOrEmpty(updated.SharedLogId))
            {
                areEqual = !string.IsNullOrEmpty(old.SharedLogId) && (old.SharedLogId == updated.SharedLogId);
            }

            if (areEqual && !string.IsNullOrEmpty(updated.SharedLogPath))
            {
                areEqual = !string.IsNullOrEmpty(old.SharedLogPath) && (old.SharedLogPath == updated.SharedLogPath);
            }

            if (areEqual && updated.MaxStreamSizeInMB.HasValue)
            {
                areEqual = old.MaxStreamSizeInMB.HasValue && (old.MaxStreamSizeInMB.Value == updated.MaxStreamSizeInMB.Value);
            }

            if (areEqual && updated.MaxRecordSizeInKB.HasValue)
            {
                areEqual = old.MaxRecordSizeInKB.HasValue && (old.MaxRecordSizeInKB.Value == updated.MaxRecordSizeInKB.Value);
            }

            if (areEqual && updated.MaxMetadataSizeInKB.HasValue)
            {
                areEqual = old.MaxMetadataSizeInKB.HasValue && (old.MaxMetadataSizeInKB.Value == updated.MaxMetadataSizeInKB.Value);
            }

            if (areEqual && updated.OptimizeForLocalSSD.HasValue)
            {
                areEqual = old.OptimizeForLocalSSD.HasValue && (old.OptimizeForLocalSSD.Value == updated.OptimizeForLocalSSD.Value);
            }

            if (areEqual && updated.OptimizeLogForLowerDiskUsage.HasValue)
            {
                areEqual = old.OptimizeLogForLowerDiskUsage.HasValue && (old.OptimizeLogForLowerDiskUsage.Value == updated.OptimizeLogForLowerDiskUsage.Value);
            }

            if (areEqual && updated.CheckpointThresholdInMB.HasValue)
            {
                areEqual = old.CheckpointThresholdInMB.HasValue && (old.CheckpointThresholdInMB.Value == updated.CheckpointThresholdInMB.Value);
            }

            if (areEqual && updated.MaxAccumulatedBackupLogSizeInMB.HasValue)
            {
                areEqual = old.MaxAccumulatedBackupLogSizeInMB.HasValue && (old.MaxAccumulatedBackupLogSizeInMB.Value == updated.MaxAccumulatedBackupLogSizeInMB.Value);
            }

            if (areEqual && updated.MinLogSizeInMB.HasValue)
            {
                areEqual = old.MinLogSizeInMB.HasValue && (old.MinLogSizeInMB.Value == updated.MinLogSizeInMB.Value);
            }

            if (areEqual && updated.TruncationThresholdFactor.HasValue)
            {
                areEqual = old.TruncationThresholdFactor.HasValue && (old.TruncationThresholdFactor.Value == updated.TruncationThresholdFactor.Value);
            }

            if (areEqual && updated.ThrottlingThresholdFactor.HasValue)
            {
                areEqual = old.ThrottlingThresholdFactor.HasValue && (old.ThrottlingThresholdFactor.Value == updated.ThrottlingThresholdFactor.Value);
            }

            if (areEqual && updated.SlowApiMonitoringDuration.HasValue)
            {
                areEqual = old.SlowApiMonitoringDuration.HasValue && (old.SlowApiMonitoringDuration == updated.SlowApiMonitoringDuration);
            }

#if !DotNetCoreClr
            // 12529905 - Disable new configuration for LogTruncationIntervalSeconds in CoreCLR
            if (areEqual && updated.LogTruncationIntervalSeconds.HasValue)
            {
                areEqual = old.LogTruncationIntervalSeconds.HasValue && (old.LogTruncationIntervalSeconds == updated.LogTruncationIntervalSeconds);
            }

            if (areEqual && updated.EnableIncrementalBackupsAcrossReplicas.HasValue)
            {
                areEqual = old.EnableIncrementalBackupsAcrossReplicas.HasValue && (old.EnableIncrementalBackupsAcrossReplicas == updated.EnableIncrementalBackupsAcrossReplicas);
            }
#endif
            return(areEqual);
        }
コード例 #3
0
        private ReliableStateManagerReplicatorSettings LoadReplicatorSettingsFromConfigPackage(bool addChangeListener)
        {
            ReliableStateManagerReplicatorSettings settings = null;

            var configPackage = this.GetConfigurationPackage();

            if (configPackage == null)
            {
                settings = new ReliableStateManagerReplicatorSettings();
            }
            else
            {
                if (string.IsNullOrEmpty(this._configuration.ReplicatorSettingsSectionName) ||
                    !configPackage.Settings.Sections.Contains(this._configuration.ReplicatorSettingsSectionName))
                {
                    DataImplTrace.Source.WriteWarningWithId(
                        TraceType,
                        this._traceId,
                        "Using default replicator settings, unable to load replicator settings config section named '{0}' from config package named '{1}'.",
                        this._configuration.ReplicatorSettingsSectionName,
                        this._configuration.ConfigPackageName);

                    settings = new ReliableStateManagerReplicatorSettings();
                }
                else
                {
                    DataImplTrace.Source.WriteInfoWithId(
                        TraceType,
                        this._traceId,
                        "Loading replicator settings using <config package name: '{0}', settings section name: '{1}'>",
                        this._configuration.ConfigPackageName,
                        this._configuration.ReplicatorSettingsSectionName);

                    settings = ReliableStateManagerReplicatorSettingsUtil.LoadFrom(
                        this.InitializationParameters.CodePackageActivationContext,
                        this._configuration.ConfigPackageName,
                        this._configuration.ReplicatorSettingsSectionName);
                }

                // SecurityCredentials.LoadFrom doesn't return the correct value when CredentialType is None in config.  todo: find bug#
                // To workaround this bug, only read replicator security settings if CredentialType is present and not explicitly None.
                const string replicatorCredentialTypeName = "CredentialType";
                if (string.IsNullOrEmpty(this._configuration.ReplicatorSecuritySectionName) ||
                    !configPackage.Settings.Sections.Contains(this._configuration.ReplicatorSecuritySectionName) ||
                    !configPackage.Settings.Sections[this._configuration.ReplicatorSecuritySectionName].Parameters.Contains(replicatorCredentialTypeName)
                    ||
                    configPackage.Settings.Sections[this._configuration.ReplicatorSecuritySectionName].Parameters[replicatorCredentialTypeName].Value.Equals(
                        "None",
                        StringComparison.OrdinalIgnoreCase))
                {
                    DataImplTrace.Source.WriteWarningWithId(
                        TraceType,
                        this._traceId,
                        "Using default replicator security settings, unable to load replicator security settings config section named '{0}' from config package named '{1}'.",
                        this._configuration.ReplicatorSecuritySectionName,
                        this._configuration.ConfigPackageName);
                }
                else
                {
                    if (addChangeListener)
                    {
                        this.InitializationParameters.CodePackageActivationContext.ConfigurationPackageModifiedEvent += this.OnConfigurationPackageModified;
                    }

                    settings.SecurityCredentials = SecurityCredentials.LoadFrom(
                        this.InitializationParameters.CodePackageActivationContext,
                        this._configuration.ConfigPackageName,
                        this._configuration.ReplicatorSecuritySectionName);
                }
            }

            if (string.IsNullOrWhiteSpace(settings.ReplicatorAddress))
            {
                settings.ReplicatorAddress = this.TryGetDefaultReplicatorAddress();
            }

            return(settings);
        }
コード例 #4
0
 /// <summary>
 /// Create a new ReliableStateManagerConfiguration.
 /// </summary>
 /// <param name="replicatorSettings">Replicator settings used to initialize the ReliableStateManager.</param>
 /// <param name="onInitializeStateSerializersEvent">
 /// Optional callback which will fire when custom serializers should be added.
 /// Used to set the <see cref="OnInitializeStateSerializersEvent"/> property.
 /// </param>
 public ReliableStateManagerConfiguration(
     ReliableStateManagerReplicatorSettings replicatorSettings,
     Func<Task> onInitializeStateSerializersEvent = null)
     : this(replicatorSettings, null, null, null, onInitializeStateSerializersEvent)
 {
 }