public ConfigurationUpgradeFabricRequest(IFabricClient fabricClient, ConfigurationUpgradeDescription upgradeDescription, TimeSpan timeout)
: base(fabricClient, timeout)
{
ThrowIf.Null(upgradeDescription, "upgradeDescription");
this.UpgradeDescription = upgradeDescription;
this.ConfigureErrorCodes();
}
public void ConfigurationUpgradeDescription_ParseTest()
{
ConfigurationUpgradeDescription expected = HelperInstance.CreateDefaultDescription();
using (var pc = new PinCollection())
{
IntPtr native = expected.ToNative(pc);
ConfigurationUpgradeDescription actual = ConfigurationUpgradeDescription.CreateFromNative(native);
HelperInstance.Compare(expected, actual);
}
}
public NativeCommon.IFabricAsyncOperationContext BeginUpgradeConfiguration(IntPtr startUpgradeDescription, uint timeoutMilliseconds, NativeCommon.IFabricAsyncOperationCallback callback)
{
var managedStartUpgradeDescription = ConfigurationUpgradeDescription.CreateFromNative(startUpgradeDescription);
TimeSpan managedTimeout = TimeSpan.FromMilliseconds(timeoutMilliseconds);
return(Utility.WrapNativeAsyncMethodImplementation(
(cancellationToken) =>
this.StartClusterConfigurationUpgradeAsync(
managedStartUpgradeDescription,
managedTimeout,
cancellationToken),
callback,
"UpgradeOrchestrationServiceBroker.StartClusterConfigurationUpgrade",
ThreadErrorMessageSetter));
}
public void ConfigUpgradeDescConstructorTest()
{
ConfigurationUpgradeDescription desc = new ConfigurationUpgradeDescription();
Assert.AreEqual(null, desc.ClusterConfiguration);
Assert.AreEqual(TimeSpan.FromSeconds(600), desc.HealthCheckRetryTimeout);
Assert.AreEqual(TimeSpan.Zero, desc.HealthCheckStableDuration);
Assert.AreEqual(TimeSpan.Zero, desc.HealthCheckWaitDuration);
Assert.AreEqual(0, desc.MaxPercentDeltaUnhealthyNodes);
Assert.AreEqual(0, desc.MaxPercentUnhealthyApplications);
Assert.AreEqual(0, desc.MaxPercentUnhealthyNodes);
Assert.AreEqual(0, desc.MaxPercentUpgradeDomainDeltaUnhealthyNodes);
Assert.AreEqual(TimeSpan.MaxValue, desc.UpgradeDomainTimeout);
Assert.AreEqual(TimeSpan.MaxValue, desc.UpgradeTimeout);
Console.WriteLine(desc.ToStringDescription());
}
public async Task StartClusterConfigurationUpgrade(
ConfigurationUpgradeDescription configurationUpgradeDescription,
TimeSpan timeout,
CancellationToken cancellationToken)
{
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Enter StartClusterConfigurationUpgrade.");
UpgradeOrchestrationTrace.TraceSource.WriteInfo(
TraceType,
"startUpgradeDescription: {0}",
configurationUpgradeDescription.ClusterConfiguration);
try
{
await this.MessageProcessor.ProcessStartClusterConfigurationUpgradeAsync(configurationUpgradeDescription, timeout, cancellationToken);
}
catch (Exception e)
{
UpgradeOrchestrationTrace.TraceSource.WriteWarning(TraceType, "{0} - Exception occurred", e);
throw;
}
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Exit StartClusterConfigurationUpgrade.");
}
private Task StartClusterConfigurationUpgradeAsync(ConfigurationUpgradeDescription startUpgradeDescription, TimeSpan timeout, CancellationToken cancellationToken)
{
return(this.service.StartClusterConfigurationUpgrade(startUpgradeDescription, timeout, cancellationToken));
}
public async Task ProcessStartClusterConfigurationUpgradeAsync(ConfigurationUpgradeDescription configUpgradeDesc, TimeSpan timeout, CancellationToken cancellationToken)
{
/* The cancellation token passed in this API call is not used (by design). This token corresponds to the client side call.
* The global this.cancellationToken is initialised in RunAsync() and is honored in every API call. */
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Entering ProcessStartUpgradeAsync.");
try
{
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Deserializing input json config string.");
StandAloneInstallerJsonModelBase targetJsonConfig = StandAloneInstallerJsonModelBase.GetJsonConfigFromString(configUpgradeDesc.ClusterConfiguration);
if (targetJsonConfig == null)
{
throw new ArgumentException("The input cluster configuration is not in a valid json format or supported apiVersion.");
}
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Retrieve current cluster resource from StoreManager.");
StandAloneCluster cluster = await this.storeManager.GetClusterResourceAsync(
Constants.ClusterReliableDictionaryKey, this.cancellationToken).ConfigureAwait(false);
bool isInDataLossState = await DatalossHelper.IsInDatalossStateAsync(this.cancellationToken).ConfigureAwait(false);
if (!isInDataLossState)
{
if (cluster == null || cluster.Current == null)
{
UpgradeOrchestrationTrace.TraceSource.WriteWarning(TraceType, "Persisted cluster resource is not ready: {0}", cluster == null ? "null" : "current = null");
throw new FabricException("UpgradeOrchestrationService is not ready.");
}
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Setting target config and topology based on new input json config.");
if (cluster.Pending != null && !this.IsInterruptibleAsync(cluster.Pending).Result)
{
throw new FabricException(string.Format("Cluster configuration upgrade of type {0} is already in progress and cannot be interrupted.", cluster.Pending.GetType().Name));
}
StandaloneSettingsValidator validator = new StandaloneSettingsValidator(targetJsonConfig);
await UpgradeOrchestrationMessageProcessor.ValidateModel(targetJsonConfig, validator, cluster, true).ConfigureAwait(false);
var removedNodes = validator.GetRemovedNodes(cluster.Topology);
var addedNodes = validator.GetAddedNodes(cluster.Topology);
if (addedNodes.Any() && StandaloneUtility.CheckFabricRunningAsGMSA(cluster.Current.CSMConfig))
{
/* Need to resolve assembly so that FabricDeployer can load the right binaries from FabricCodePath since not all binaries required by FabricDeployer are present in UOS.Current folder.*/
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(this.LoadFromFabricCodePath);
try
{
await this.PerformAddNodeOperationGMSAAsync(addedNodes, this.fabricClient, validator.ClusterProperties.NodeTypes).ConfigureAwait(false);
}
catch (AggregateException ex)
{
UpgradeOrchestrationTrace.TraceSource.WriteError(TraceType, "Adding nodes for GMSA scenario failed with exception: {0}", ex);
throw;
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= new ResolveEventHandler(this.LoadFromFabricCodePath);
}
}
if (addedNodes.Any())
{
cluster.TargetNodeConfig = GetTargetNodeConfigAddNode(validator.Topology, cluster.Current.NodeConfig.Version);
}
if (removedNodes.Any())
{
cluster.TargetNodeConfig = GetTargetNodeConfigRemoveNode(cluster.Topology, removedNodes, cluster.Current.NodeConfig.Version);
}
else
{
cluster.Topology = validator.Topology;
}
cluster.TargetCsmConfig = validator.ClusterProperties;
// Cluster is updated above so persist it.
await this.storeManager.PersistClusterResourceAsync(Constants.ClusterReliableDictionaryKey, cluster, cancellationToken).ConfigureAwait(false);
await this.UpdatePersistedCodeUpgradePackage(validator).ConfigureAwait(false);
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Invoking Orchestrator");
await this.orchestrator.StartUpgradeAsync(cluster, this.cancellationToken, configUpgradeDesc).ContinueWith(t =>
{
if (t.Exception != null)
{
UpgradeOrchestrationTrace.TraceSource.WriteWarning(TraceType, "Orchestrator completed with status: {0} exception: {1}", t.Status, t.Exception);
}
else
{
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Orchestrator completed with status: {0}", t.Status);
}
});
}
else
{
StandaloneSettingsValidator validator = new StandaloneSettingsValidator(targetJsonConfig);
await UpgradeOrchestrationMessageProcessor.ValidateModel(targetJsonConfig, validator, cluster, false).ConfigureAwait(false);
cluster = FabricUpgradeOrchestrationService.ConstructClusterFromJson(targetJsonConfig, FabricNativeConfigStore.FabricGetConfigStore());
DatalossHelper.DryRunConfigUpgrade(cluster);
await this.storeManager.PersistClusterResourceAsync(Constants.ClusterReliableDictionaryKey, cluster, this.cancellationToken);
await DatalossHelper.UpdateHeathStateAsync(isHealthy : true).ConfigureAwait(false);
}
}
catch (Exception e)
{
UpgradeOrchestrationTrace.TraceSource.WriteWarning(TraceType, "ProcessStartUpgradeAsync exception: {0}", e);
throw UpgradeOrchestrationMessageProcessor.ConvertToComException(e);
}
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Exiting ProcessStartUpgradeAsync.");
}
protected override void ProcessRecord()
{
var clusterConnection = this.GetClusterConnection();
try
{
string clusterConfigAbsolutePath = GetAbsolutePath(this.ClusterConfigPath);
string jsonConfigString = File.ReadAllText(clusterConfigAbsolutePath);
var description = new ConfigurationUpgradeDescription
{
ClusterConfiguration = jsonConfigString
};
if (this.HealthCheckRetryTimeoutSec.HasValue)
{
description.HealthCheckRetryTimeout = TimeSpan.FromSeconds(this.HealthCheckRetryTimeoutSec.Value);
}
if (this.HealthCheckWaitDurationSec.HasValue)
{
description.HealthCheckWaitDuration = TimeSpan.FromSeconds(this.HealthCheckWaitDurationSec.Value);
}
if (this.HealthCheckStableDurationSec.HasValue)
{
description.HealthCheckStableDuration = TimeSpan.FromSeconds(this.HealthCheckStableDurationSec.Value);
}
if (this.UpgradeDomainTimeoutSec.HasValue)
{
description.UpgradeDomainTimeout = TimeSpan.FromSeconds(this.UpgradeDomainTimeoutSec.Value);
}
if (this.UpgradeTimeoutSec.HasValue)
{
description.UpgradeTimeout = TimeSpan.FromSeconds(this.UpgradeTimeoutSec.Value);
}
description.MaxPercentUnhealthyApplications =
this.MaxPercentUnhealthyApplications ?? description.MaxPercentUnhealthyApplications;
description.MaxPercentUnhealthyNodes =
this.MaxPercentUnhealthyNodes ?? description.MaxPercentUnhealthyNodes;
description.MaxPercentDeltaUnhealthyNodes =
this.MaxPercentDeltaUnhealthyNodes ?? description.MaxPercentDeltaUnhealthyNodes;
description.MaxPercentUpgradeDomainDeltaUnhealthyNodes =
this.MaxPercentUpgradeDomainDeltaUnhealthyNodes ?? description.MaxPercentUpgradeDomainDeltaUnhealthyNodes;
if (this.ApplicationHealthPolicies != null)
{
foreach (var entry in this.ApplicationHealthPolicies)
{
description.ApplicationHealthPolicies.Add(entry.Key, entry.Value);
}
}
clusterConnection.StartClusterConfigurationUpgradeAsync(
description,
this.GetTimeout(),
this.GetCancellationToken()).Wait();
}
catch (AggregateException aggregateException)
{
aggregateException.Handle((ae) =>
{
this.ThrowTerminatingError(
ae,
Constants.StartClusterConfigurationUpgradeErrorId,
clusterConnection);
return(true);
});
}
}
