/// <summary>
/// Serializes the object to JSON.
/// </summary>
/// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
/// <param name="obj">The object to serialize to JSON.</param>
internal static void Serialize(JsonWriter writer, ApplicationUpgradeDescription obj)
{
// Required properties are always serialized, optional properties are serialized when not null.
writer.WriteStartObject();
writer.WriteProperty(obj.UpgradeKind, "UpgradeKind", UpgradeKindConverter.Serialize);
writer.WriteProperty(obj.Name, "Name", JsonWriterExtensions.WriteStringValue);
writer.WriteProperty(obj.TargetApplicationTypeVersion, "TargetApplicationTypeVersion", JsonWriterExtensions.WriteStringValue);
writer.WriteProperty(obj.Parameters, "Parameters", ApplicationParametersConverter.Serialize);
writer.WriteProperty(obj.RollingUpgradeMode, "RollingUpgradeMode", UpgradeModeConverter.Serialize);
if (obj.UpgradeReplicaSetCheckTimeoutInSeconds != null)
{
writer.WriteProperty(obj.UpgradeReplicaSetCheckTimeoutInSeconds, "UpgradeReplicaSetCheckTimeoutInSeconds", JsonWriterExtensions.WriteLongValue);
}
if (obj.ForceRestart != null)
{
writer.WriteProperty(obj.ForceRestart, "ForceRestart", JsonWriterExtensions.WriteBoolValue);
}
if (obj.MonitoringPolicy != null)
{
writer.WriteProperty(obj.MonitoringPolicy, "MonitoringPolicy", MonitoringPolicyDescriptionConverter.Serialize);
}
if (obj.ApplicationHealthPolicy != null)
{
writer.WriteProperty(obj.ApplicationHealthPolicy, "ApplicationHealthPolicy", ApplicationHealthPolicyConverter.Serialize);
}
writer.WriteEndObject();
}
public static async Task DeployServiceFabricApp(this IServiceFabricClient Client, ServiceFabricApplicationSpec app, ILogger Logger = null)
{
var serverAppVersions = await Client.Applications.GetApplicationInfoListAsync();
var deployed = serverAppVersions.Data.FirstOrDefault(sa => sa.Name == "fabric:/" + app.Name);
if (deployed != null)
{
if (deployed.TypeVersion == app.Version)
{
Logger?.LogInfo($"{app.Name} version {app.Version} is already deployed");
return;
}
var upgradeDescription = new ApplicationUpgradeDescription("fabric:/" + app.Name, app.Version, UpgradeKind.Rolling, app.Parameters, UpgradeMode.Monitored, 15);
Logger?.LogInfo($"Upgrading app {upgradeDescription.Name} to version {upgradeDescription.TargetApplicationTypeVersion}");
await Client.Applications.StartApplicationUpgradeAsync(app.Name, upgradeDescription);
}
else
{
var appDescription = new ApplicationDescription("fabric:/" + app.Name, app.Manifest.ApplicationTypeName, app.Manifest.ApplicationTypeVersion, app.Parameters);
Logger?.LogInfo($"Creating app {appDescription.Name} with type {appDescription.TypeName} version {appDescription.TypeVersion}");
Logger?.LogVerbose($"With parameters");
if (appDescription.Parameters != null)
{
foreach (var parameter in appDescription.Parameters.Keys)
{
Logger?.LogVerbose($"{parameter} = {appDescription.Parameters[(string)parameter]}");
}
}
await Client.Applications.CreateApplicationAsync(appDescription);
}
}
public UpgradeApplicationRequest(IFabricClient fabricClient, ApplicationUpgradeDescription upgradeDescription, TimeSpan timeout)
: base(fabricClient, timeout)
{
ThrowIf.Null(upgradeDescription, "upgradeDescription");
this.UpgradeDescription = upgradeDescription;
this.ConfigureErrorCodes();
}
/// <inheritdoc />
public Task StartApplicationUpgradeAsync(
string applicationId,
ApplicationUpgradeDescription applicationUpgradeDescription,
long?serverTimeout = 60,
CancellationToken cancellationToken = default(CancellationToken))
{
applicationId.ThrowIfNull(nameof(applicationId));
applicationUpgradeDescription.ThrowIfNull(nameof(applicationUpgradeDescription));
serverTimeout?.ThrowIfOutOfInclusiveRange("serverTimeout", 1, 4294967295);
var requestId = Guid.NewGuid().ToString();
var url = "Applications/{applicationId}/$/Upgrade";
url = url.Replace("{applicationId}", applicationId);
var queryParams = new List <string>();
// Append to queryParams if not null.
serverTimeout?.AddToQueryParameters(queryParams, $"timeout={serverTimeout}");
queryParams.Add("api-version=6.0");
url += "?" + string.Join("&", queryParams);
string content;
using (var sw = new StringWriter())
{
ApplicationUpgradeDescriptionConverter.Serialize(new JsonTextWriter(sw), applicationUpgradeDescription);
content = sw.ToString();
}
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Post,
Content = new StringContent(content, Encoding.UTF8)
};
request.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
return(request);
}
return(this.httpClient.SendAsync(RequestFunc, url, requestId, cancellationToken));
}
/// <inheritdoc/>
protected override void ProcessRecordInternal()
{
var monitoringPolicyDescription = new MonitoringPolicyDescription(
failureAction: this.FailureAction,
healthCheckWaitDurationInMilliseconds: this.HealthCheckWaitDurationInMilliseconds,
healthCheckStableDurationInMilliseconds: this.HealthCheckStableDurationInMilliseconds,
healthCheckRetryTimeoutInMilliseconds: this.HealthCheckRetryTimeoutInMilliseconds,
upgradeTimeoutInMilliseconds: this.UpgradeTimeoutInMilliseconds,
upgradeDomainTimeoutInMilliseconds: this.UpgradeDomainTimeoutInMilliseconds);
var serviceTypeHealthPolicy = new ServiceTypeHealthPolicy(
maxPercentUnhealthyPartitionsPerService: this.MaxPercentUnhealthyPartitionsPerService,
maxPercentUnhealthyReplicasPerPartition: this.MaxPercentUnhealthyReplicasPerPartition,
maxPercentUnhealthyServices: this.MaxPercentUnhealthyServices);
var applicationHealthPolicy = new ApplicationHealthPolicy(
considerWarningAsError: this.ConsiderWarningAsError,
maxPercentUnhealthyDeployedApplications: this.MaxPercentUnhealthyDeployedApplications,
defaultServiceTypeHealthPolicy: serviceTypeHealthPolicy,
serviceTypeHealthPolicyMap: this.ServiceTypeHealthPolicyMap);
var applicationUpgradeDescription = new ApplicationUpgradeDescription(
name: $"fabric:/{this.ApplicationId}",
targetApplicationTypeVersion: this.TargetApplicationTypeVersion,
parameters: this.Parameters?.ToDictionary <string, string>(),
upgradeKind: this.UpgradeKind,
rollingUpgradeMode: this.RollingUpgradeMode,
upgradeReplicaSetCheckTimeoutInSeconds: this.UpgradeReplicaSetCheckTimeoutInSeconds,
forceRestart: this.ForceRestart,
monitoringPolicy: monitoringPolicyDescription,
applicationHealthPolicy: applicationHealthPolicy);
this.ServiceFabricClient.Applications.StartApplicationUpgradeAsync(
applicationId: this.ApplicationId,
applicationUpgradeDescription: applicationUpgradeDescription,
serverTimeout: this.ServerTimeout,
cancellationToken: this.CancellationToken).GetAwaiter().GetResult();
Console.WriteLine("Success!");
}
public async Task RunAsync()
{
var item = _context.CurrentDeploymentItem;
try
{
LogInfo(
StageTypes.Deployment,
$"Upgrading application {item.ApplicationName} to version {item.ApplicationTypeVersion}...");
var appUpgradeDesc = new ApplicationUpgradeDescription(
item.ApplicationName,
item.ApplicationTypeVersion,
UpgradeKind.Rolling,
item.Parameters,
item.UpgradeMode ?? UpgradeMode.UnmonitoredAuto);
await _context.AppClient.StartApplicationUpgradeAsync(item.ApplicationId, appUpgradeDesc);
var upgraded = await CheckUpgradeApplicationStatusAsync(item);
if (upgraded)
{
LogInfo(StageTypes.Deployment, $"Upgraded application {item.ApplicationName} successfully");
}
else
{
var message = "The application failed to startup within " +
$"{item.MaxApplicationReadyWaitTime} seconds";
LogError(StageTypes.Deployment, $"Failed to upgrade application {item.ApplicationName}: {message}");
}
}
catch (Exception error)
{
LogError(
StageTypes.Deployment,
$"Failed to upgrade application {item.ApplicationName} to version " +
$"{item.ApplicationTypeVersion}: {error.Message}");
}
}
protected void UpgradeApplication(ApplicationUpgradeDescription upgradeDescription)
{
var clusterConnection = this.GetClusterConnection();
try
{
clusterConnection.UpgradeApplicationAsync(
upgradeDescription,
this.GetTimeout(),
this.GetCancellationToken()).Wait();
this.WriteObject(this.FormatOutput(upgradeDescription), true);
}
catch (AggregateException aggregateException)
{
aggregateException.Handle((ae) =>
{
this.ThrowTerminatingError(
ae,
Constants.UpgradeApplicationErrorId,
clusterConnection);
return(true);
});
}
}
protected override void ProcessRecord()
{
try
{
if (this.ReplicaQuorumTimeoutSec.HasValue)
{
this.WriteWarning(StringResources.PowerShell_ReplicaQuorumTimeoutSec_Deprecated);
if (!this.UpgradeReplicaSetCheckTimeoutSec.HasValue)
{
this.UpgradeReplicaSetCheckTimeoutSec = this.ReplicaQuorumTimeoutSec.Value;
}
}
if (this.RestartProcess)
{
this.WriteWarning(StringResources.PowerShell_RestartProcess_Deprecated);
if (!this.ForceRestart)
{
this.ForceRestart = this.RestartProcess;
}
}
RollingUpgradePolicyDescription policyDescription;
if (this.Monitored)
{
var monitoringPolicy = new RollingUpgradeMonitoringPolicy();
if (this.FailureAction == UpgradeFailureAction.Invalid)
{
this.FailureAction = Constants.DefaultUpgradeFailureAction;
}
monitoringPolicy.FailureAction = this.FailureAction;
if (this.HealthCheckRetryTimeoutSec.HasValue)
{
monitoringPolicy.HealthCheckRetryTimeout = TimeSpan.FromSeconds(this.HealthCheckRetryTimeoutSec.Value);
}
if (this.HealthCheckWaitDurationSec.HasValue)
{
monitoringPolicy.HealthCheckWaitDuration = TimeSpan.FromSeconds(this.HealthCheckWaitDurationSec.Value);
}
if (this.HealthCheckStableDurationSec.HasValue)
{
monitoringPolicy.HealthCheckStableDuration = TimeSpan.FromSeconds(this.HealthCheckStableDurationSec.Value);
}
if (this.UpgradeDomainTimeoutSec.HasValue)
{
monitoringPolicy.UpgradeDomainTimeout = TimeSpan.FromSeconds(this.UpgradeDomainTimeoutSec.Value);
}
if (this.UpgradeTimeoutSec.HasValue)
{
monitoringPolicy.UpgradeTimeout = TimeSpan.FromSeconds(this.UpgradeTimeoutSec.Value);
}
var monitoredPolicyDescription = new MonitoredRollingApplicationUpgradePolicyDescription
{
UpgradeMode = RollingUpgradeMode.Monitored,
ForceRestart = this.ForceRestart,
MonitoringPolicy = monitoringPolicy
};
policyDescription = monitoredPolicyDescription;
if (this.IsUpdatingHealthPolicy())
{
if (!this.Force && !this.IsHealthPolicyComplete() && !this.ShouldProcess(
//// description shows up for "-WhatIf"
string.Format(
CultureInfo.InvariantCulture,
"{0} {1}",
StringResources.PowerShell_HealthPolicyUpgradeCaption,
StringResources.PowerShell_ApplicationHealthPolicyUpdateWarning),
//// warning and caption show up when prompting for confirmation
StringResources.PowerShell_ApplicationHealthPolicyUpdateWarning,
StringResources.PowerShell_HealthPolicyUpgradeCaption))
{
return;
}
var healthPolicy = new ApplicationHealthPolicy();
if (this.ConsiderWarningAsError.HasValue)
{
healthPolicy.ConsiderWarningAsError = this.ConsiderWarningAsError.Value;
}
if (this.DefaultServiceTypeHealthPolicy != null)
{
healthPolicy.DefaultServiceTypeHealthPolicy = this.ParseServiceTypeHealthPolicy(this.DefaultServiceTypeHealthPolicy);
}
if (this.MaxPercentUnhealthyDeployedApplications.HasValue)
{
healthPolicy.MaxPercentUnhealthyDeployedApplications = this.MaxPercentUnhealthyDeployedApplications.Value;
}
if (this.ServiceTypeHealthPolicyMap != null)
{
foreach (DictionaryEntry entry in this.ServiceTypeHealthPolicyMap)
{
healthPolicy.ServiceTypeHealthPolicyMap.Add(entry.Key as string, this.ParseServiceTypeHealthPolicy(entry.Value as string));
}
}
monitoredPolicyDescription.HealthPolicy = healthPolicy;
}
}
else if (this.UnmonitoredManual)
{
policyDescription = new RollingUpgradePolicyDescription
{
UpgradeMode = RollingUpgradeMode.UnmonitoredManual,
ForceRestart = this.ForceRestart,
};
}
else
{
policyDescription = new RollingUpgradePolicyDescription
{
UpgradeMode = RollingUpgradeMode.UnmonitoredAuto,
ForceRestart = this.ForceRestart,
};
}
if (this.UpgradeReplicaSetCheckTimeoutSec.HasValue)
{
policyDescription.UpgradeReplicaSetCheckTimeout = TimeSpan.FromSeconds(this.UpgradeReplicaSetCheckTimeoutSec.Value);
}
var upgradeDescription = new ApplicationUpgradeDescription
{
ApplicationName = this.ApplicationName,
TargetApplicationTypeVersion = this.ApplicationTypeVersion,
UpgradePolicyDescription = policyDescription
};
upgradeDescription.ApplicationParameters.Add(this.GetNameValueCollection(this.ApplicationParameter));
this.UpgradeApplication(upgradeDescription);
}
catch (Exception exception)
{
this.ThrowTerminatingError(
exception,
Constants.UpgradeApplicationErrorId,
null);
}
}
/// <summary>
/// start an application upgrade
/// </summary>
/// <param name="fromPackage">from package</param>
/// <param name="toPackage">to package</param>
/// <param name="isRolling">specify if rolling</param>
/// <param name="mode">monitor mode</param>
/// <param name="timeout">timeout for upgrade start</param>
/// <returns>true if upgrade started</returns>
public bool TryApplicationUpgrade(PackageSettings fromPackage, PackageSettings toPackage, bool isRolling, UpgradeMonitor mode, TimeSpan timeout)
{
this.LastException = null;
try
{
ApplicationUpgradeDescription upgradeDescription = new ApplicationUpgradeDescription();
// we use the "from" package's address
upgradeDescription.ApplicationName = new Uri(fromPackage.ApplicationAddress);
// we use the "to" package's version
upgradeDescription.TargetApplicationTypeVersion = toPackage.ApplicationVersion;
// split parameters if any are specified
NameValueCollection upgradeParams = Control64.GetApplicationParameters(toPackage);
if (upgradeParams != null && upgradeParams.Count > 0)
{
upgradeDescription.ApplicationParameters.Add(upgradeParams);
}
RollingUpgradePolicyDescription policy = new RollingUpgradePolicyDescription();
policy.ForceRestart = true;
policy.UpgradeMode = RollingUpgradeMode.UnmonitoredManual;
if (isRolling)
{
switch (mode)
{
case UpgradeMonitor.Auto:
policy.UpgradeMode = RollingUpgradeMode.UnmonitoredAuto;
break;
case UpgradeMonitor.Manual:
policy.UpgradeMode = RollingUpgradeMode.UnmonitoredManual;
break;
}
policy.UpgradeReplicaSetCheckTimeout = timeout;
}
upgradeDescription.UpgradePolicyDescription = policy;
this.fc.ApplicationManager.UpgradeApplicationAsync(upgradeDescription, Defaults.UpgradeTimeout, CancellationToken.None).Wait();
return true;
}
catch (Exception e)
{
this.LastException = e;
if (e is AggregateException)
{
if (e is FabricException)
{
log.Error("Upgrade failed: " + e.InnerException.Message);
return false;
}
log.Error("UpgradeApplication Aggregate failure, err={0}", e.InnerException.Message);
}
else
{
log.Error("UpgradeApplication failed, err={0}", e.Message);
}
}
return false;
}
protected PSObject ToPSObject(ApplicationUpgradeDescription upgradeDescription)
{
var itemPSObj = new PSObject(upgradeDescription);
if (upgradeDescription.ApplicationParameters != null)
{
var parametersPropertyPSObj = new PSObject(upgradeDescription.ApplicationParameters);
parametersPropertyPSObj.Members.Add(
new PSCodeMethod(
Constants.ToStringMethodName,
typeof(OutputFormatter).GetMethod(Constants.FormatObjectMethodName)));
itemPSObj.Properties.Add(
new PSNoteProperty(
Constants.ApplicationParametersPropertyName,
parametersPropertyPSObj));
}
if (upgradeDescription.UpgradePolicyDescription == null)
{
return(itemPSObj);
}
var monitoredPolicy = upgradeDescription.UpgradePolicyDescription as MonitoredRollingApplicationUpgradePolicyDescription;
if (monitoredPolicy != null)
{
itemPSObj.Properties.Add(new PSNoteProperty(Constants.UpgradeKindPropertyName, monitoredPolicy.Kind));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.ForceRestartPropertyName, monitoredPolicy.ForceRestart));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.UpgradeModePropertyName, monitoredPolicy.UpgradeMode));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.UpgradeReplicaSetCheckTimeoutPropertyName, monitoredPolicy.UpgradeReplicaSetCheckTimeout));
if (monitoredPolicy.MonitoringPolicy != null)
{
itemPSObj.Properties.Add(new PSNoteProperty(Constants.FailureActionPropertyName, monitoredPolicy.MonitoringPolicy.FailureAction));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.HealthCheckWaitDurationPropertyName, monitoredPolicy.MonitoringPolicy.HealthCheckWaitDuration));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.HealthCheckStableDurationPropertyName, monitoredPolicy.MonitoringPolicy.HealthCheckStableDuration));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.HealthCheckRetryTimeoutPropertyName, monitoredPolicy.MonitoringPolicy.HealthCheckRetryTimeout));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.UpgradeDomainTimeoutPropertyName, monitoredPolicy.MonitoringPolicy.UpgradeDomainTimeout));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.UpgradeTimeoutPropertyName, monitoredPolicy.MonitoringPolicy.UpgradeTimeout));
}
if (monitoredPolicy.HealthPolicy != null)
{
this.AddToPSObject(itemPSObj, monitoredPolicy.HealthPolicy);
}
}
else
{
var policy = upgradeDescription.UpgradePolicyDescription as RollingUpgradePolicyDescription;
if (policy != null)
{
itemPSObj.Properties.Add(new PSNoteProperty(Constants.UpgradeKindPropertyName, policy.Kind));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.ForceRestartPropertyName, policy.ForceRestart));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.UpgradeModePropertyName, policy.UpgradeMode));
itemPSObj.Properties.Add(new PSNoteProperty(Constants.UpgradeReplicaSetCheckTimeoutPropertyName, policy.UpgradeReplicaSetCheckTimeout));
}
}
return(itemPSObj);
}
internal static ApplicationUpgradeProgress CreateFromNative(NativeClient.IFabricApplicationUpgradeProgressResult3 nativeResult)
{
if (nativeResult == null)
{
return(null);
}
var progress = new ApplicationUpgradeProgress(nativeResult);
progress.ApplicationName = NativeTypes.FromNativeUri(nativeResult.get_ApplicationName());
progress.ApplicationTypeName = NativeTypes.FromNativeString(nativeResult.get_ApplicationTypeName());
progress.TargetApplicationTypeVersion = NativeTypes.FromNativeString(nativeResult.get_TargetApplicationTypeVersion());
switch (nativeResult.get_UpgradeState())
{
case NativeTypes.FABRIC_APPLICATION_UPGRADE_STATE.APPLICATION_UPGRADE_STATE_ROLLBACK_IN_PROGRESS:
case NativeTypes.FABRIC_APPLICATION_UPGRADE_STATE.APPLICATION_UPGRADE_STATE_ROLLBACK_COMPLETED:
case NativeTypes.FABRIC_APPLICATION_UPGRADE_STATE.APPLICATION_UPGRADE_STATE_ROLLBACK_PENDING:
case NativeTypes.FABRIC_APPLICATION_UPGRADE_STATE.APPLICATION_UPGRADE_STATE_ROLLFORWARD_PENDING:
case NativeTypes.FABRIC_APPLICATION_UPGRADE_STATE.APPLICATION_UPGRADE_STATE_ROLLFORWARD_IN_PROGRESS:
case NativeTypes.FABRIC_APPLICATION_UPGRADE_STATE.APPLICATION_UPGRADE_STATE_ROLLFORWARD_COMPLETED:
case NativeTypes.FABRIC_APPLICATION_UPGRADE_STATE.APPLICATION_UPGRADE_STATE_FAILED:
progress.UpgradeState = (ApplicationUpgradeState)nativeResult.get_UpgradeState();
break;
default:
progress.UpgradeState = ApplicationUpgradeState.Invalid;
break;
}
uint count = 0;
IntPtr pointer = nativeResult.GetUpgradeDomains(out count);
progress.UpgradeDomains = UpgradeDomainHelper.CreateUpgradeDomainsFromNative(count, pointer);
switch (nativeResult.get_RollingUpgradeMode())
{
case NativeTypes.FABRIC_ROLLING_UPGRADE_MODE.FABRIC_ROLLING_UPGRADE_MODE_UNMONITORED_AUTO:
case NativeTypes.FABRIC_ROLLING_UPGRADE_MODE.FABRIC_ROLLING_UPGRADE_MODE_UNMONITORED_MANUAL:
case NativeTypes.FABRIC_ROLLING_UPGRADE_MODE.FABRIC_ROLLING_UPGRADE_MODE_MONITORED:
progress.RollingUpgradeMode = (RollingUpgradeMode)nativeResult.get_RollingUpgradeMode();
break;
default:
progress.RollingUpgradeMode = RollingUpgradeMode.Invalid;
break;
}
progress.NextUpgradeDomain = NativeTypes.FromNativeString(nativeResult.get_NextUpgradeDomain());
IntPtr upgradeProgressPtr = nativeResult.get_UpgradeProgress();
if (upgradeProgressPtr != IntPtr.Zero)
{
unsafe
{
var castedProgressPtr = (NativeTypes.FABRIC_APPLICATION_UPGRADE_PROGRESS *)upgradeProgressPtr;
progress.UpgradeDescription = ApplicationUpgradeDescription.FromNative(castedProgressPtr->UpgradeDescription);
progress.UpgradeDuration = TimeSpan.FromSeconds(castedProgressPtr->UpgradeDurationInSeconds);
progress.CurrentUpgradeDomainDuration = TimeSpan.FromSeconds(castedProgressPtr->CurrentUpgradeDomainDurationInSeconds);
progress.UnhealthyEvaluations = HealthEvaluation.FromNativeList(castedProgressPtr->UnhealthyEvaluations);
progress.CurrentUpgradeDomainProgress = UpgradeDomainProgress.FromNative(castedProgressPtr->CurrentUpgradeDomainProgress);
if (castedProgressPtr->Reserved != IntPtr.Zero)
{
var castedProgressEx1Ptr = (NativeTypes.FABRIC_APPLICATION_UPGRADE_PROGRESS_EX1 *)castedProgressPtr->Reserved;
progress.StartTimestampUtc = NativeTypes.FromNullableNativeFILETIME(castedProgressEx1Ptr->StartTimestampUtc);
progress.FailureTimestampUtc = NativeTypes.FromNullableNativeFILETIME(castedProgressEx1Ptr->FailureTimestampUtc);
if (progress.FailureTimestampUtc.HasValue)
{
switch (castedProgressEx1Ptr->FailureReason)
{
case NativeTypes.FABRIC_UPGRADE_FAILURE_REASON.FABRIC_UPGRADE_FAILURE_REASON_INTERRUPTED:
case NativeTypes.FABRIC_UPGRADE_FAILURE_REASON.FABRIC_UPGRADE_FAILURE_REASON_HEALTH_CHECK:
case NativeTypes.FABRIC_UPGRADE_FAILURE_REASON.FABRIC_UPGRADE_FAILURE_REASON_UPGRADE_DOMAIN_TIMEOUT:
case NativeTypes.FABRIC_UPGRADE_FAILURE_REASON.FABRIC_UPGRADE_FAILURE_REASON_OVERALL_UPGRADE_TIMEOUT:
case NativeTypes.FABRIC_UPGRADE_FAILURE_REASON.FABRIC_UPGRADE_FAILURE_REASON_PROCESSING_FAILURE:
progress.FailureReason = (UpgradeFailureReason)castedProgressEx1Ptr->FailureReason;
break;
default:
progress.FailureReason = UpgradeFailureReason.None;
break;
}
progress.UpgradeDomainProgressAtFailure = UpgradeDomainProgress.FromNative(
castedProgressEx1Ptr->UpgradeDomainProgressAtFailure);
}
if (castedProgressEx1Ptr->Reserved != IntPtr.Zero)
{
var castedProgressEx2Ptr = (NativeTypes.FABRIC_APPLICATION_UPGRADE_PROGRESS_EX2 *)castedProgressEx1Ptr->Reserved;
progress.UpgradeStatusDetails = NativeTypes.FromNativeString(castedProgressEx2Ptr->UpgradeStatusDetails);
}
}
}
}
GC.KeepAlive(nativeResult);
return(progress);
}
/// <summary>
/// start an application upgrade
/// </summary>
/// <param name="fromPackage">from package</param>
/// <param name="toPackage">to package</param>
/// <param name="isRolling">specify if rolling</param>
/// <param name="mode">monitor mode</param>
/// <param name="timeout">timeout for upgrade start</param>
/// <returns>true if upgrade started</returns>
public bool TryApplicationUpgrade(PackageSettings fromPackage, PackageSettings toPackage, bool isRolling, UpgradeMonitor mode, TimeSpan timeout)
{
this.LastException = null;
try
{
ApplicationUpgradeDescription upgradeDescription = new ApplicationUpgradeDescription();
// we use the "from" package's address
upgradeDescription.ApplicationName = new Uri(fromPackage.ApplicationAddress);
// we use the "to" package's version
upgradeDescription.TargetApplicationTypeVersion = toPackage.ApplicationVersion;
// split parameters if any are specified
NameValueCollection upgradeParams = Control64.GetApplicationParameters(toPackage);
if (upgradeParams != null && upgradeParams.Count > 0)
{
upgradeDescription.ApplicationParameters.Add(upgradeParams);
}
RollingUpgradePolicyDescription policy = new RollingUpgradePolicyDescription();
policy.ForceRestart = true;
policy.UpgradeMode = RollingUpgradeMode.UnmonitoredManual;
if (isRolling)
{
switch (mode)
{
case UpgradeMonitor.Auto:
policy.UpgradeMode = RollingUpgradeMode.UnmonitoredAuto;
break;
case UpgradeMonitor.Manual:
policy.UpgradeMode = RollingUpgradeMode.UnmonitoredManual;
break;
}
policy.UpgradeReplicaSetCheckTimeout = timeout;
}
upgradeDescription.UpgradePolicyDescription = policy;
this.fc.ApplicationManager.UpgradeApplicationAsync(upgradeDescription, Defaults.UpgradeTimeout, CancellationToken.None).Wait();
return(true);
}
catch (Exception e)
{
this.LastException = e;
if (e is AggregateException)
{
if (e is FabricException)
{
log.Error("Upgrade failed: " + e.InnerException.Message);
return(false);
}
log.Error("UpgradeApplication Aggregate failure, err={0}", e.InnerException.Message);
}
else
{
log.Error("UpgradeApplication failed, err={0}", e.Message);
}
}
return(false);
}
public override async Task UpdateAsync(IOperationDescription description, IFabricOperationResult result, IOperationContext context)
{
Trace.WriteInfo(TraceType, "UpdateAsync called");
description.ThrowIfNull(nameof(description));
result.ThrowIfNull(nameof(result));
result.OperationStatus.ThrowIfNull(nameof(result.OperationStatus));
result.QueryResult.ThrowIfNull(nameof(result.QueryResult));
context.ThrowIfNull(nameof(context));
string errorMessage;
if (!this.ValidObjectType<ApplicationOperationDescription>(description, out errorMessage))
{
throw new InvalidCastException(errorMessage);
}
if (!this.ValidObjectType<ApplicationFabricQueryResult>(result.QueryResult, out errorMessage))
{
throw new InvalidCastException(errorMessage);
}
var appDescription = (ApplicationOperationDescription)description;
appDescription.TypeVersion.ThrowIfNullOrWhiteSpace(nameof(appDescription.TypeVersion));
appDescription.ApplicationUri.ThrowIfNull(nameof(appDescription.ApplicationUri));
var appResult = (ApplicationFabricQueryResult)result.QueryResult;
var healthPolicy = new ApplicationHealthPolicy();
var defaultServiceTypeHealthPolicy = new ServiceTypeHealthPolicy();
if (appDescription.UpgradePolicy?.ApplicationHealthPolicy != null)
{
healthPolicy.ConsiderWarningAsError =
appDescription.UpgradePolicy.ApplicationHealthPolicy.ConsiderWarningAsError;
healthPolicy.MaxPercentUnhealthyDeployedApplications =
appDescription.UpgradePolicy.ApplicationHealthPolicy.MaxPercentUnhealthyDeployedApplications;
if (appDescription.UpgradePolicy.ApplicationHealthPolicy.DefaultServiceTypeHealthPolicy != null)
{
defaultServiceTypeHealthPolicy.MaxPercentUnhealthyPartitionsPerService =
appDescription.UpgradePolicy.ApplicationHealthPolicy.DefaultServiceTypeHealthPolicy
.MaxPercentUnhealthyPartitionsPerService;
defaultServiceTypeHealthPolicy.MaxPercentUnhealthyReplicasPerPartition =
appDescription.UpgradePolicy.ApplicationHealthPolicy.DefaultServiceTypeHealthPolicy
.MaxPercentUnhealthyReplicasPerPartition;
defaultServiceTypeHealthPolicy.MaxPercentUnhealthyServices =
appDescription.UpgradePolicy.ApplicationHealthPolicy.DefaultServiceTypeHealthPolicy
.MaxPercentUnhealthyServices;
healthPolicy.DefaultServiceTypeHealthPolicy = defaultServiceTypeHealthPolicy;
}
}
var monitoringPolicy = new RollingUpgradeMonitoringPolicy();
if (appDescription.UpgradePolicy?.RollingUpgradeMonitoringPolicy != null)
{
monitoringPolicy.FailureAction =
(UpgradeFailureAction) Enum.Parse(
typeof (UpgradeFailureAction),
appDescription.UpgradePolicy.RollingUpgradeMonitoringPolicy.FailureAction.ToString(),
true);
monitoringPolicy.HealthCheckRetryTimeout =
appDescription.UpgradePolicy.RollingUpgradeMonitoringPolicy.HealthCheckRetryTimeout;
monitoringPolicy.HealthCheckStableDuration =
appDescription.UpgradePolicy.RollingUpgradeMonitoringPolicy.HealthCheckStableDuration;
monitoringPolicy.HealthCheckWaitDuration =
appDescription.UpgradePolicy.RollingUpgradeMonitoringPolicy.HealthCheckWaitDuration;
monitoringPolicy.UpgradeDomainTimeout =
appDescription.UpgradePolicy.RollingUpgradeMonitoringPolicy.UpgradeDomainTimeout;
monitoringPolicy.UpgradeTimeout = appDescription.UpgradePolicy.RollingUpgradeMonitoringPolicy.UpgradeTimeout;
}
var policyDescription = new MonitoredRollingApplicationUpgradePolicyDescription()
{
UpgradeMode = RollingUpgradeMode.Monitored,
HealthPolicy = healthPolicy,
MonitoringPolicy = monitoringPolicy
};
if (appDescription.UpgradePolicy != null)
{
if (appDescription.UpgradePolicy.ForceRestart.HasValue)
{
policyDescription.ForceRestart = appDescription.UpgradePolicy.ForceRestart.Value;
}
if (appDescription.UpgradePolicy.UpgradeReplicaSetCheckTimeout.HasValue)
{
policyDescription.UpgradeReplicaSetCheckTimeout = appDescription.UpgradePolicy.UpgradeReplicaSetCheckTimeout.Value;
}
}
// Update
var updateDescription = new ApplicationUpdateDescription(appDescription.ApplicationUri)
{
RemoveApplicationCapacity = appDescription.RemoveApplicationCapacity
};
if (appDescription.MinimumNodes.HasValue)
{
updateDescription.MinimumNodes = appDescription.MinimumNodes.Value;
}
if (appDescription.MaximumNodes.HasValue)
{
updateDescription.MaximumNodes = appDescription.MaximumNodes.Value;
}
if (appDescription.Metrics != null && appDescription.Metrics.Any())
{
updateDescription.Metrics = new List<ApplicationMetricDescription>();
foreach (var metric in appDescription.Metrics)
{
updateDescription.Metrics.Add(
new ApplicationMetricDescription()
{
Name = metric.Name,
MaximumNodeCapacity = metric.MaximumCapacity,
NodeReservationCapacity = metric.ReservationCapacity,
TotalApplicationCapacity = metric.TotalApplicationCapacity
});
}
}
Trace.WriteInfo(
TraceType,
"UpdateAsync: Updating application. Name: {0}. Timeout: {1}",
updateDescription.ApplicationName,
context.OperationTimeout);
await this.fabricClient.ApplicationManager.UpdateApplicationAsync(
updateDescription,
context.OperationTimeout,
context.CancellationToken);
Trace.WriteInfo(TraceType, "UpdateAsync: Application update call accepted");
// Upgrade
var upgradeDescription = new ApplicationUpgradeDescription()
{
ApplicationName = appDescription.ApplicationUri,
TargetApplicationTypeVersion = appDescription.TypeVersion,
UpgradePolicyDescription = policyDescription
};
if (appDescription.Parameters != null)
{
upgradeDescription.ApplicationParameters.Add(appDescription.Parameters.ToNameValueCollection());
}
try
{
Trace.WriteInfo(
TraceType,
"UpdateAsync: Upgrading application. Name: {0}. Version: {1}. TargetVersion: {2}. Timeout: {3}",
upgradeDescription.ApplicationName,
appResult.Application.ApplicationTypeVersion,
upgradeDescription.TargetApplicationTypeVersion,
context.OperationTimeout);
await this.fabricClient.ApplicationManager.UpgradeApplicationAsync(
upgradeDescription,
context.OperationTimeout,
context.CancellationToken);
Trace.WriteInfo(TraceType, "UpdateAsync: Application upgrade call accepted");
}
catch (FabricException fe)
{
if (fe.ErrorCode == FabricErrorCode.ApplicationAlreadyInTargetVersion)
{
Trace.WriteInfo(TraceType, "UpdateAsync: Application already in target version: {0}.", upgradeDescription.TargetApplicationTypeVersion);
return;
}
if (fe.ErrorCode == FabricErrorCode.ApplicationUpgradeInProgress)
{
Trace.WriteInfo(TraceType, "UpdateAsync: Application upgrade in progress with same version: {0}", upgradeDescription.TargetApplicationTypeVersion);
}
else
{
Trace.WriteError(TraceType, "UpdateAsync: Application upgrade encountered an exception: {0}", fe);
throw;
}
}
catch (Exception e)
{
Trace.WriteInfo(TraceType, "UpdateAsync: Application upgrade encountered an exception: {0}", e);
throw;
}
// UpgradeUpdate
ApplicationUpgradeProgress upgradeProgress = null;
try
{
upgradeProgress = await this.fabricClient.ApplicationManager.GetApplicationUpgradeProgressAsync(
appDescription.ApplicationUri,
context.OperationTimeout,
context.CancellationToken);
}
catch (Exception)
{
Trace.WriteWarning(
TraceType,
"UpdateAsync: Failed to get the application upgrade progress to determine the parameters for upgrade update. Need to retry the operation. Application Name: {0}",
appDescription.ApplicationUri);
throw new FabricTransientException();
}
ApplicationUpgradeUpdateDescription upgradeUpdateDescription;
if (upgradeProgress.UpgradeState == ApplicationUpgradeState.RollingBackInProgress)
{
// During rollback we can only change below properties
upgradeUpdateDescription = new ApplicationUpgradeUpdateDescription()
{
ApplicationName = appDescription.ApplicationUri,
UpgradeReplicaSetCheckTimeout = appDescription.UpgradePolicy.UpgradeReplicaSetCheckTimeout,
ForceRestart = appDescription.UpgradePolicy.ForceRestart
};
}
else
{
upgradeUpdateDescription = new ApplicationUpgradeUpdateDescription()
{
ApplicationName = appDescription.ApplicationUri,
UpgradeDomainTimeout = monitoringPolicy.UpgradeDomainTimeout,
UpgradeTimeout = monitoringPolicy.UpgradeTimeout,
HealthCheckRetryTimeout = monitoringPolicy.HealthCheckRetryTimeout,
HealthCheckWaitDuration = monitoringPolicy.HealthCheckWaitDuration,
HealthCheckStableDuration = monitoringPolicy.HealthCheckStableDuration,
UpgradeReplicaSetCheckTimeout = policyDescription.UpgradeReplicaSetCheckTimeout,
ForceRestart = policyDescription.ForceRestart,
FailureAction = monitoringPolicy.FailureAction,
HealthPolicy = healthPolicy
};
}
try
{
Trace.WriteInfo(
TraceType,
"UpdateAsync: Updating application upgrade in progress. Name: {0}. Timeout: {1}",
upgradeUpdateDescription.ApplicationName,
context.OperationTimeout);
await this.fabricClient.ApplicationManager.UpdateApplicationUpgradeAsync(
upgradeUpdateDescription,
context.OperationTimeout,
context.CancellationToken);
Trace.WriteInfo(TraceType, "UpdateAsync: Update application upgrade call accepted");
}
catch (FabricException fe)
{
if (fe.ErrorCode == FabricErrorCode.ApplicationNotUpgrading)
{
Trace.WriteInfo(TraceType, "UpdateAsync: No application upgrade in progress");
return;
}
}
catch (Exception e)
{
Trace.WriteInfo(TraceType, "UpdateAsync: Update application upgrade encountered an exception: {0}", e);
throw;
}
}
public async Task <IActionResult> CreateDeployment([FromServices] FabricClient fabric, [FromBody] DeploymentModel deploymentModel)
{
logger.LogInformation("Using {fabricClient}", fabric.Settings.ClientFriendlyName);
using (var stream = await new HttpClient().GetStreamAsync(deploymentModel.RemoteUrl))
{
var zip = new ZipArchive(stream, ZipArchiveMode.Read);
var entry = zip.GetEntry("ApplicationManifest.xml");
XDocument xDocument = await XDocument.LoadAsync(entry.Open(), LoadOptions.None, HttpContext.RequestAborted);
deploymentModel.ApplicationTypeName = xDocument.Root.Attribute("ApplicationTypeName").Value;
deploymentModel.ApplicationTypeVersion = xDocument.Root.Attribute("ApplicationTypeVersion").Value;
logger.LogInformation("Updated deployment model {@deploymentModel}", deploymentModel);
}
var types = await fabric.QueryManager.GetApplicationTypeListAsync(deploymentModel.ApplicationTypeName);
if (!types.Any(a => a.ApplicationTypeName == deploymentModel.ApplicationTypeName && a.ApplicationTypeVersion == deploymentModel.ApplicationTypeVersion))
{
logger.LogInformation("Starting to provision {@deploymentModel}", deploymentModel);
// fabric.ApplicationManager.CreateApplicationAsync(new System.Fabric.Description.ApplicationDescription{ )
await fabric.ApplicationManager.ProvisionApplicationAsync(
new ExternalStoreProvisionApplicationTypeDescription(
applicationPackageDownloadUri : new Uri(deploymentModel.RemoteUrl),
applicationTypeName : deploymentModel.ApplicationTypeName,
applicationTypeVersion : deploymentModel.ApplicationTypeVersion
), TimeSpan.FromMinutes(5), HttpContext.RequestAborted
);
logger.LogInformation("Completed to provision {@deploymentModel}", deploymentModel);
}
var applicationName = new Uri($"fabric:/{deploymentModel.ApplicationName}");
var applications = await fabric.QueryManager.GetApplicationListAsync(applicationName);
if (!applications.Any(application => application.ApplicationName == applicationName))
{
await CreateApplication(deploymentModel, fabric, applicationName);
}
else
{
var existing = applications.FirstOrDefault(a => a.ApplicationName == applicationName);
if (deploymentModel.DeleteIfExists)
{
foreach (var param in existing.ApplicationParameters)
{
deploymentModel.Parameters.Add(param.Name, param.Value);
}
await fabric.ApplicationManager.DeleteApplicationAsync(new DeleteApplicationDescription(applicationName));
await Task.Delay(1000);
await CreateApplication(deploymentModel, fabric, applicationName);
}
else
{
var upgrade = new ApplicationUpgradeDescription
{
ApplicationName = applicationName,
TargetApplicationTypeVersion = deploymentModel.ApplicationTypeVersion,
UpgradePolicyDescription = new MonitoredRollingApplicationUpgradePolicyDescription()
{
UpgradeMode = RollingUpgradeMode.Monitored,
MonitoringPolicy = new RollingUpgradeMonitoringPolicy()
{
FailureAction = UpgradeFailureAction.Rollback
}
}
};
foreach (var param in existing.ApplicationParameters)
{
upgrade.ApplicationParameters.Add(param.Name, deploymentModel.Parameters.ContainsKey(param.Name) ? deploymentModel.Parameters[param.Name]: param.Value);
}
foreach (var param in deploymentModel.Parameters.Where(k => !existing.ApplicationParameters.Any(a => a.Name == k.Key)))
{
upgrade.ApplicationParameters.Add(param.Key, param.Value);
}
await fabric.ApplicationManager.UpgradeApplicationAsync(upgrade);
}
}
return(CreatedAtRoute(nameof(CreateDeployment), new { }));
}