private static string GetReplicatorAddress()
{
NativeConfigStore configStore = System.Fabric.Common.NativeConfigStore.FabricGetConfigStore();
string replicatorAddress = configStore.ReadUnencryptedString("FabricNode", "UpgradeServiceReplicatorAddress");
return(replicatorAddress);
}
private SecuritySetting()
{
this.configStore = NativeConfigStore.FabricGetConfigStore(this);
string serverAuthCredentialTypeName = configStore.ReadUnencryptedString(SecurityConfigSectionName, ServerAuthCredentialTypeName);
CredentialType serverAuthCredentialType = CredentialType.None;
if ((!string.IsNullOrEmpty(serverAuthCredentialTypeName)) &&
(!Enum.TryParse <CredentialType>(serverAuthCredentialTypeName, out serverAuthCredentialType)))
{
EventStoreLogger.Logger.LogWarning(
"Unable to convert configuration value serverAuthCredentialTypeName {0} for {1} type.",
serverAuthCredentialTypeName,
serverAuthCredentialType);
}
this.ServerAuthCredentialType = serverAuthCredentialType;
if (ServerAuthCredentialType == CredentialType.X509)
{
this.EndpointProtocol = EndpointProtocol.Https;
}
else
{
this.EndpointProtocol = EndpointProtocol.Http;
}
this.AllowedClientCertThumbprints = null;
this.AllowedClientIdentities = null;
this.AllowedClientCertCommonNames = null;
this.InitializeFromConfig();
}
public AADSettings()
{
this.configValuesLock = new RwLock();
this.nativeConfigStore = NativeConfigStore.FabricGetConfigStore(this);
this.LoadGlobalDefaultSettings();
}
private bool IsPackageNearExpiry(PackageDetails currentPackage)
{
bool isNearExpiry = false;
NativeConfigStore configStore = NativeConfigStore.FabricGetConfigStore();
string goalStateExpirationReminderInDaysString = configStore.ReadUnencryptedString(DMConstants.UpgradeOrchestrationServiceConfigSectionName, DMConstants.GoalStateExpirationReminderInDays);
uint goalStateExpirationReminderInDays;
if (string.IsNullOrEmpty(goalStateExpirationReminderInDaysString) || !uint.TryParse(goalStateExpirationReminderInDaysString, out goalStateExpirationReminderInDays))
{
this.traceSource.WriteInfo(
TraceType,
"goalStateExpirationReminderInDays value invalid: \"{0}\". Defaulting to {1}.",
goalStateExpirationReminderInDaysString,
DMConstants.DefaultGoalStateExpirationReminderInDays);
goalStateExpirationReminderInDays = DMConstants.DefaultGoalStateExpirationReminderInDays;
}
if (currentPackage != null && currentPackage.SupportExpiryDate != null)
{
isNearExpiry = (currentPackage.SupportExpiryDate - DateTime.UtcNow).Value.TotalDays < goalStateExpirationReminderInDays;
}
return(isNearExpiry);
}
private static StatefulServiceBase ReadConfiguration(StatefulServiceContext context)
{
var configStore = NativeConfigStore.FabricGetConfigStore();
var backupRestoreServiceReplicatorAddress = configStore.ReadUnencryptedString("FabricNode", "BackupRestoreServiceReplicatorAddress");
return(new BackupRestoreService(context, backupRestoreServiceReplicatorAddress));
}
public EncryptionCertConfigHandler(Action <string, string, CancellationToken> encryptionCertChangeCallback,
StatefulService statefulService, CancellationToken runAsyncCancellationToken)
{
this.updateCertCallback = encryptionCertChangeCallback;
this.runAsyncCancellationToken = runAsyncCancellationToken;
this.statefulService = statefulService;
this.nativeConfigStore = NativeConfigStore.FabricGetConfigStore();
}
internal void LoadSettings(NativeConfigStore nativeConfig)
{
this.DSTSDnsName = nativeConfig.ReadUnencryptedString(DSTSSectionName, DSTSDnsNameKey);
this.DSTSRealm = nativeConfig.ReadUnencryptedString(DSTSSectionName, DSTSRealmKey);
this.ServiceDnsName = nativeConfig.ReadUnencryptedString(DSTSSectionName, TVSServiceDnsNameKey);
this.ServiceName = nativeConfig.ReadUnencryptedString(DSTSSectionName, ServiceNameKey);
this.TokenValidationServiceType = nativeConfig.ReadUnencryptedString(DSTSSectionName, TokenValidationServiceTypeKey);
}
public static bool GetValue(NativeConfigStore configStore)
{
ThrowIf.Null(configStore, "configStore");
string value = configStore.ReadUnencryptedString("Common", "EnableEndpointV2");
bool flag = string.IsNullOrEmpty(value) ? false : bool.Parse(value);
return(flag);
}
private string GetValueFromManifest(SettingsOverridesTypeSection section, string parameterName)
{
var parameter = section == null ? null : section.Parameter.FirstOrDefault(par => par.Name.Equals(parameterName, StringComparison.OrdinalIgnoreCase));
var value = parameter == null ? null : parameter.Value;
if (parameter != null && parameter.IsEncrypted && value != null)
{
value = NativeConfigStore.DecryptText(value).ToString();
}
DeployerTrace.WriteInfo("Setup section, parameter {0}, has value {1}", parameterName, value);
return(value);
}
public ClusterEndpointSecuritySettingsChangeNotifier(string endpoint, Action <string> updateReplicatorSettingsAction)
{
if (updateReplicatorSettingsAction == null)
{
throw new ArgumentNullException("updateReplicatorSettingsAction");
}
// null is allowed for endpoint
this.endpoint = endpoint;
this.updateReplicatorSettingsAction = updateReplicatorSettingsAction;
this.configStore = NativeConfigStore.FabricGetConfigStore(this);
}
static BackupRestoreServiceConfig()
{
// Read value from config store
var configStore = NativeConfigStore.FabricGetConfigStore();
var apiTimeoutString = configStore.ReadUnencryptedString(BackupRestoreContants.BrsConfigSectionName, BackupRestoreContants.ApiTimeoutKeyName);
ApiTimeout = String.IsNullOrEmpty(apiTimeoutString) ? BackupRestoreContants.ApiTimeoutInSecondsDefault : TimeSpan.FromSeconds(int.Parse(apiTimeoutString, CultureInfo.InvariantCulture));
var workItemTimeoutString = configStore.ReadUnencryptedString(BackupRestoreContants.BrsConfigSectionName, WorkItemTimeoutKeyName);
WorkItemTimeout = String.IsNullOrEmpty(workItemTimeoutString) ? DefaultWorkItemTimeout : TimeSpan.FromSeconds(int.Parse(workItemTimeoutString, CultureInfo.InvariantCulture));
}
public static void InitializeFromConfigStore(bool forceUpdate = false)
{
lock (SyncLock)
{
if (configReader != null && !forceUpdate)
{
return;
}
configReader = new ConfigReader(NativeConfigStore.FabricGetConfigStore(UpdateHandler));
}
InitializeFromConfigStore(configReader);
}
private static void Ensure_IgnoreUpdateFailures()
{
if (!ignoreUpdateFailures)
{
lock (configLock)
{
if (!ignoreUpdateFailures)
{
configStore = NativeConfigStore.FabricGetConfigStore();
configStore.IgnoreUpdateFailures = true;
ignoreUpdateFailures = true;
}
}
}
}
private void LoadJiterConfig()
{
string jitterInSecondsString = null;
try
{
var configStore = NativeConfigStore.FabricGetConfigStore();
jitterInSecondsString = configStore.ReadUnencryptedString(BackupRestoreContants.BrsConfigSectionName, BackupRestoreContants.JitterInBackupsKeyName);
}
catch (Exception) { }
var jitterInSeconds = String.IsNullOrEmpty(jitterInSecondsString) ? BackupRestoreContants.JitterInBackupsDefault : int.Parse(jitterInSecondsString, CultureInfo.InvariantCulture);
this.jitter = Math.Abs(jitterInSeconds) * 1000;
}
public DsmsAzureStorageHelper(string sourceLocation)
{
var configStore = NativeConfigStore.FabricGetConfigStore();
var ApServiceName = configStore.ReadUnencryptedString(BackupRestoreContants.BrsConfigSectionName, BackupRestoreContants.DsmsAutopilotServiceNameKeyName);
if (string.IsNullOrEmpty(ApServiceName))
{
CredentialManagementClient.Instance.ClientInitialize();
}
else
{
CredentialManagementClient.Instance.ClientInitializeForAp(ApServiceName);
}
this.dsmsCredentials = DsmsStorageCredentials.GetStorageCredentials(sourceLocation);
}
private void UpdateTimers()
{
try
{
NativeConfigStore configStore = NativeConfigStore.FabricGetConfigStore();
string goalStateFetchIntervalInSecondsString = configStore.ReadUnencryptedString(DMConstants.UpgradeOrchestrationServiceConfigSectionName, DMConstants.GoalStateFetchIntervalInSecondsName);
int goalStateFetchIntervalInSeconds;
if (string.IsNullOrEmpty(goalStateFetchIntervalInSecondsString) || !int.TryParse(goalStateFetchIntervalInSecondsString, out goalStateFetchIntervalInSeconds))
{
this.traceSource.WriteInfo(
TraceType,
"goalStateFetchIntervalInSeconds value invalid: \"{0}\". Defaulting to {1}.",
goalStateFetchIntervalInSecondsString,
DMConstants.DefaultGoalStateFetchIntervalInSeconds);
goalStateFetchIntervalInSeconds = DMConstants.DefaultGoalStateFetchIntervalInSeconds;
}
this.timerInterval = TimeSpan.FromSeconds(goalStateFetchIntervalInSeconds);
string goalStateProvisioningTimeOfDayString = configStore.ReadUnencryptedString(DMConstants.UpgradeOrchestrationServiceConfigSectionName, DMConstants.GoalStateProvisioningTimeOfDayName);
TimeSpan goalStateProvisioningTimeOfDay;
if (string.IsNullOrEmpty(goalStateProvisioningTimeOfDayString) || !TimeSpan.TryParse(goalStateProvisioningTimeOfDayString, out goalStateProvisioningTimeOfDay))
{
this.traceSource.WriteInfo(
TraceType,
"goalStateProvisioningTimeOfDay value invalid: \"{0}\". Defaulting to {1}.",
goalStateProvisioningTimeOfDayString,
DMConstants.DefaultProvisioningTimeOfDay);
goalStateProvisioningTimeOfDay = DMConstants.DefaultProvisioningTimeOfDay;
}
this.provisioningTimeOfDay = goalStateProvisioningTimeOfDay;
this.traceSource.WriteInfo(
TraceType,
"Timers set to: TimerInterval: {0}, ProvisioningTimeOfDay: {1}.",
this.timerInterval.ToString(),
this.provisioningTimeOfDay.ToString());
}
catch (Exception ex)
{
this.traceSource.WriteError(TraceType, "UpdateTimers threw {0}", ex.ToString());
throw;
}
}
/// <summary>
/// This is the main entry point for your service replica.
/// This method executes when this replica of your service becomes primary and has write status.
/// </summary>
/// <param name="cancellationToken">Canceled when Service Fabric needs to shut down this service replica.</param>
protected override async Task RunAsync(CancellationToken cancellationToken)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Enter RunAsync");
FabricEvents.Events.BackupRestoreEnabled(this.Context.TraceId);
// TODO: Ensure that the requests dont come in before we do the necessary initializations which are being done below
await WorkItemHandler.StartAndScheduleWorkItemHandler(this);
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Registering config update handlers now");
var configUpdateHandler = new ConfigUpdateHandler();
configStore = NativeConfigStore.FabricGetConfigStore(configUpdateHandler);
var certConfigHandler = new EncryptionCertConfigHandler(this.EncryptionCertUpdateCallbackAsync, this, cancellationToken);
encryptionCertConfigStore = NativeConfigStore.FabricGetConfigStore(certConfigHandler);
await certConfigHandler.InitializeAsync();
Task <RetentionManager> retentionManagerTask = RetentionManager.CreateOrGetRetentionManager(this);
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Config update handlers registered");
try
{
while (!configUpdateHandler.ProcessRecycleRequired)
{
cancellationToken.ThrowIfCancellationRequested();
if (this.retentionManager == null && retentionManagerTask.IsCompleted)
{
this.retentionManager = retentionManagerTask.Result;
}
await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
}
// Process recycle is required, throwing exception from RunAsync
throw new Exception("Process recycle needed.");
}
finally
{
this.retentionManager?.StopRetentionManager();
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Exit RunAsync");
}
}
private bool UseClusterSecuritySettingsForReplicator(IConfigSection configSection)
{
NativeConfigStore configStore = NativeConfigStore.FabricGetConfigStore();
if (EnableEndpointV2Utility.GetValue(configStore))
{
TraceType.WriteInfo("Using cluster security settings for replicator because cluster setting EnableEndpointV2 is true");
return(true);
}
if (this.ReadFactoryConfig(configSection, "UseClusterSecuritySettingsForReplicator", false))
{
TraceType.WriteInfo("Using cluster security settings for replicator because UseClusterSecuritySettingsForReplicator is true");
return(true);
}
return(false);
}
public static ITokenValidationProvider Create(string configSection)
{
var nativeConfig = NativeConfigStore.FabricGetConfigStore(null);
var providersValue = nativeConfig.ReadUnencryptedString(configSection, ProvidersConfigName);
var providers = providersValue.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (providers.Length > 1)
{
// TVS API currently has no way of specifying which provider should be
// performing validation of the supplied token
throw new FabricException(
"Multiple TVS validation providers not supported",
FabricErrorCode.InvalidConfiguration);
}
// DSTS is the default provider for backwards compatibility
if (providers.Length < 1 || string.Equals(providers[0], DSTSProviderName, StringComparison.OrdinalIgnoreCase))
{
TokenValidationServiceFactory.TraceSource.WriteInfo(
TraceType,
"Creating {0} provider",
DSTSProviderName);
return(new DSTSValidationProvider(configSection));
}
else if (string.Equals(providers[0], AADProviderName, StringComparison.OrdinalIgnoreCase))
{
TokenValidationServiceFactory.TraceSource.WriteInfo(
TraceType,
"Creating {0} provider",
AADProviderName);
return(new AADValidationProvider(configSection));
}
else
{
throw new FabricException(string.Format(CultureInfo.InvariantCulture,
"Invalid TVS provider '{0}'. Valid providers are '{1}' and '{2}'",
providers[0],
DSTSProviderName,
AADProviderName),
FabricErrorCode.InvalidConfiguration);
}
}
public DSTSObjectManager(string configSection)
{
this.configSection = configSection;
this.reloadLock = new ReaderWriterLockSlim();
this.configStore = NativeConfigStore.FabricGetConfigStore(this);
this.claimsAuthEnabled = false;
try
{
this.InitializeDSTSObjects();
}
catch (Exception e)
{
TokenValidationServiceFactory.TraceSource.WriteError(DSTSObjectManager.TraceType,
"Failed to update DSTSObjects due to exception {0}, {1}",
e.GetType(),
e.Message);
throw;
}
}
public static void Main(string[] args)
{
#if !DotNetCoreClr
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
#endif
using (FabricRuntime fabricRuntime = FabricRuntime.Create())
{
ServiceRuntime.RegisterServiceAsync("EventStoreServiceType", context =>
new EventStoreService(
context,
NativeConfigStore.FabricGetConfigStore().ReadUnencryptedString(
"FabricNode",
"EventStoreServiceReplicatorAddress")))
.GetAwaiter()
.GetResult();
Thread.Sleep(Timeout.Infinite);
}
}
public static ServiceFactory CreateAndRegister()
{
try
{
IInfrastructureAgentWrapper agent = new InfrastructureAgentWrapper();
var configUpdateHandler = new FactoryConfigUpdateHandler();
NativeConfigStore configStore = NativeConfigStore.FabricGetConfigStore(configUpdateHandler);
ServiceFactory factory = new ServiceFactory(agent, configStore, null, configUpdateHandler);
agent.RegisterInfrastructureServiceFactory(factory);
return(factory);
}
catch (Exception ex)
{
TraceType.WriteError("Error registering infrastructure service factory. Cannot continue further. Exception: {0}", ex);
throw;
}
}
internal static string GetGoalStateUri()
{
string goalStateUriStr = null;
/* Test code relies on the settings present in ClusterSettings.json for deployment of a specific version.
* We need this check for the test code because certain APIs will be invoked before the cluster is even up. */
string clusterSettingsFilepath = StandaloneUtility.FindFabricResourceFile(DMConstants.ClusterSettingsFileName);
if (!string.IsNullOrEmpty(clusterSettingsFilepath))
{
StandAloneClusterManifestSettings standAloneClusterManifestSettings = JsonConvert.DeserializeObject <StandAloneClusterManifestSettings>(File.ReadAllText(clusterSettingsFilepath));
if (standAloneClusterManifestSettings.CommonClusterSettings != null && standAloneClusterManifestSettings.CommonClusterSettings.Section != null)
{
SettingsTypeSection settings = standAloneClusterManifestSettings.CommonClusterSettings.Section.ToList().SingleOrDefault(
section => section.Name == DMConstants.UpgradeOrchestrationServiceConfigSectionName);
if (settings != null)
{
SettingsTypeSectionParameter goalStatePathParam = settings.Parameter.ToList().SingleOrDefault(param => param.Name == DMConstants.GoalStateFileUrlName);
if (goalStatePathParam != null)
{
goalStateUriStr = goalStatePathParam.Value;
}
}
}
}
// Check the native config store before using default location. The GoalStateFileUrl may have been overridden by the user.
if (string.IsNullOrEmpty(goalStateUriStr))
{
NativeConfigStore configStore = NativeConfigStore.FabricGetConfigStore();
goalStateUriStr = configStore.ReadUnencryptedString(DMConstants.UpgradeOrchestrationServiceConfigSectionName, DMConstants.GoalStateFileUrlName);
}
if (string.IsNullOrEmpty(goalStateUriStr))
{
goalStateUriStr = DMConstants.DefaultGoalStateFileUrl;
}
return(goalStateUriStr);
}
private Task InitClusterAnalysisEngineAsync(FabricClient fabricClient, NativeConfigStore configStore, CancellationToken cancellationToken)
{
#if DotNetCoreClr
TestabilityTrace.TraceSource.WriteInfo(FaultAnalysisServiceTraceType, "Skipping Cluster Analysis in .Net Core environment");
return(Task.FromResult(true));
#else
string clusterAnalysisEnabledAsString = configStore.ReadUnencryptedString(FASConstants.FaultAnalysisServiceConfigSectionName, ClusterAnalysisEnabledConfig);
if (string.IsNullOrWhiteSpace(clusterAnalysisEnabledAsString))
{
TestabilityTrace.TraceSource.WriteWarning(FaultAnalysisServiceTraceType, "ClusterAnalysisEnabled feature Flag is Null/Empty. Skipping Cluster Analysis.");
return(Task.FromResult(true));
}
bool clusterAnalysisEnabled = false;
if (!bool.TryParse(clusterAnalysisEnabledAsString, out clusterAnalysisEnabled))
{
TestabilityTrace.TraceSource.WriteInfo(FaultAnalysisServiceTraceType, "ClusterAnalysisConfig : {0} Couldn't be parsed. Skipping Cluster Analysis.", clusterAnalysisEnabledAsString);
clusterAnalysisEnabled = false;
}
if (!clusterAnalysisEnabled)
{
TestabilityTrace.TraceSource.WriteInfo(FaultAnalysisServiceTraceType, "Cluster Anaysis Feature Status is Disabled");
return(Task.FromResult(true));
}
TestabilityTrace.TraceSource.WriteInfo(FaultAnalysisServiceTraceType, "Launching Cluster Analysis");
this.clusterAnalysisApiHandler = new System.Fabric.FaultAnalysis.Service.ClusterAnalysis.ClusterAnalysisApiHandler(this.StateManager, fabricClient, cancellationToken);
try
{
return(this.clusterAnalysisApiHandler.InternalLaunchAsync(cancellationToken));
}
catch (Exception e)
{
TestabilityTrace.TraceSource.WriteError(FaultAnalysisServiceTraceType, "Exception Launching Cluster Analysis " + e);
throw;
}
#endif
}
internal void LoadSettings(NativeConfigStore nativeConfig)
{
this.LinuxProxyImageName = nativeConfig.ReadUnencryptedString(this.GRMSectionName, LinuxProxyImageNameKey);
this.WindowsProxyImageName = nativeConfig.ReadUnencryptedString(this.GRMSectionName, WindowsProxyImageNameKey);
this.ProxyReplicaCount = nativeConfig.ReadUnencryptedString(this.GRMSectionName, ProxyReplicaCountKey);
this.ImageStoreConnectionString = nativeConfig.ReadUnencryptedString("Management", ImageStoreConnectionStringKey);
this.IPProviderEnabled = nativeConfig.ReadUnencryptedBool("Hosting", IPProviderEnabledKey, GatewayResourceManagerTrace.TraceSource, Program.TraceType, false);
this.LocalNatIPProviderEnabled = nativeConfig.ReadUnencryptedBool("Hosting", LocalNatIPProviderEnabledKey, GatewayResourceManagerTrace.TraceSource, Program.TraceType, false);
this.IsolatedNetworkSetup = nativeConfig.ReadUnencryptedBool("Setup", IsolatedNetworkSetupKey, GatewayResourceManagerTrace.TraceSource, Program.TraceType, false);
this.ContainerNetworkSetup = nativeConfig.ReadUnencryptedBool("Setup", ContainerNetworkSetupKey, GatewayResourceManagerTrace.TraceSource, Program.TraceType, false);
var proxyCPUCores = nativeConfig.ReadUnencryptedString(this.GRMSectionName, ProxyCPUCoresKey);
this.ProxyCPUCores = string.IsNullOrEmpty(proxyCPUCores) ? ProxyCPUCoresDefault : proxyCPUCores;
var proxyCreateToReadyTimeoutInMinutes = nativeConfig.ReadUnencryptedString(this.GRMSectionName, ProxyCreateToReadyTimeoutInMinutesKey);
this.ProxyCreateToReadyTimeoutInMinutes = string.IsNullOrEmpty(proxyCreateToReadyTimeoutInMinutes) ? ProxyCreateToReadyTimeoutInMinutesDefault : TimeSpan.FromMinutes(int.Parse(proxyCreateToReadyTimeoutInMinutes));
try
{
this.ClientCertThumbprints = nativeConfig.ReadUnencryptedString("Security", ClientCertThumbprintsKey);
}
catch (Exception)
{
this.ClientCertThumbprints = string.Empty;
}
try
{
this.ClusterCertThumbprints = nativeConfig.ReadUnencryptedString("Security", ClusterCertThumbprintsKey);
}
catch (Exception)
{
this.ClusterCertThumbprints = string.Empty;
}
}
private WindowsIdentity GetIdentityToImpersonate()
{
WindowsIdentity identity = null;
if (this.accessInfo.AccountPasswordIsEncrypted)
{
SecureString password = NativeConfigStore.DecryptText(this.accessInfo.AccountPassword);
identity = AccountHelper.CreateWindowsIdentity(
this.accessInfo.UserName,
this.accessInfo.DomainName,
password,
FileShareAccessAccountType.ManagedServiceAccount == this.accessInfo.AccountType);
}
else
{
identity = AccountHelper.CreateWindowsIdentity(
this.accessInfo.UserName,
this.accessInfo.DomainName,
this.accessInfo.AccountPassword,
FileShareAccessAccountType.ManagedServiceAccount == this.accessInfo.AccountType);
}
return identity;
}
private UpgradeSystemService(
string workingDirectory,
Guid partitionId)
: base(
workingDirectory, // (V2 only)
DatabaseSubDirectory, // (V2 only)
DatabaseFileName, // (both V1 and V2)
partitionId) // shared log ID (V2 only)
{
this.cancellationTokenSource = null;
this.configStore = NativeConfigStore.FabricGetConfigStore();
this.enableEndpointV2 = EnableEndpointV2Utility.GetValue(configStore);
this.replicatorAddress = GetReplicatorAddress();
Trace.WriteInfo(TraceType, "Read UpgradeServiceReplicatorAddress={0}", this.replicatorAddress);
if (this.enableEndpointV2)
{
this.clusterEndpointSecuritySettingsChangeNotifier = new ClusterEndpointSecuritySettingsChangeNotifier(
this.replicatorAddress,
this.UpdateReplicatorSettingsOnConfigChange);
}
}
internal static void InitializeConfigStore()
{
configStore = NativeConfigStore.FabricGetConfigStore();
return;
}
static ClusterSettingsReader()
{
configStore = NativeConfigStore.FabricGetConfigStore();
}
public static AzureTableConsumer[] GetEnabledAzureTableConsumersSettings()
{
var result = new List <AzureTableConsumer>();
var consumers = GetDiagnosticsConsumersNames();
foreach (var consumer in consumers)
{
bool isEncrypted;
AzureConsumerType consumerType;
var consumerTypeString = configStore.ReadString(
consumer,
ReaderConstants.ClusterSettings.ConsumerType,
out isEncrypted);
if (consumerTypeString != QueryableConsumerIdentifier &&
consumerTypeString != OperationalConsumerIdentifier)
{
continue;
}
if (consumerTypeString == QueryableConsumerIdentifier)
{
consumerType = AzureConsumerType.Query;
}
else
{
consumerType = AzureConsumerType.Operational;
}
bool isConnectionStringEncrypted;
var tablesPrefix = configStore.ReadString(
consumer,
ReaderConstants.ClusterSettings.TableNamePrefix,
out isEncrypted);
var connectionString = configStore.ReadString(
consumer,
ReaderConstants.ClusterSettings.StoreConnectionString,
out isConnectionStringEncrypted);
var isEnabled = configStore.ReadString(
consumer,
ReaderConstants.ClusterSettings.IsEnabled,
out isEncrypted);
if (string.IsNullOrEmpty(tablesPrefix) || string.IsNullOrEmpty(connectionString))
{
continue;
}
if (!string.IsNullOrEmpty(isEnabled) && !bool.Parse(isEnabled))
{
continue;
}
if (isConnectionStringEncrypted)
{
var secureString = NativeConfigStore.DecryptText(connectionString);
var secureCharArray = FabricValidatorUtility.SecureStringToCharArray(secureString);
connectionString = new string(secureCharArray);
}
result.Add(new AzureTableConsumer(consumerType, tablesPrefix, connectionString));
}
return(result.ToArray());
}
