protected void ValidateLROResponse(ComputeLongRunningOperationResponse lroResponse, string operationId)
{
Assert.NotNull(lroResponse);
Assert.NotNull(lroResponse.Status);
Assert.Equal(operationId, lroResponse.TrackingOperationId);
Assert.NotNull(lroResponse.StartTime);
//Assert.NotNull(lroResponse.EndTime); // TODO: it's null somtimes.
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (string.IsNullOrEmpty(this.Location))
{
this.Location = GetLocationFromVm(this.ResourceGroupName, this.VMName);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Name = Name ?? VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace + "." + VirtualMachineSqlServerExtensionContext.ExtensionPublishedName,
Type = VirtualMachineExtensionType,
Publisher = VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace,
ExtensionType = VirtualMachineSqlServerExtensionContext.ExtensionPublishedName,
TypeHandlerVersion = string.IsNullOrEmpty(this.Version) ? VirtualMachineSqlServerExtensionContext.ExtensionDefaultVersion : this.Version,
Settings = this.GetPublicConfiguration(),
ProtectedSettings = this.GetPrivateConfiguration(),
};
// Add retry logic due to CRP service restart known issue CRP bug: 3564713
// Similair approach taken in DSC cmdlet as well
var count = 1;
ComputeLongRunningOperationResponse op = null;
while (count <= 2)
{
op = VirtualMachineExtensionClient.CreateOrUpdate(
ResourceGroupName,
VMName,
parameters);
if (ComputeOperationStatus.Failed.Equals(op.Status) && op.Error != null && "InternalExecutionError".Equals(op.Error.Code))
{
count++;
}
else
{
break;
}
}
var result = Mapper.Map <PSComputeLongRunningOperation>(op);
WriteObject(result);
}
private void CreateConfiguration()
{
var publicSettings = new DscExtensionPublicSettings();
var privateSettings = new DscExtensionPrivateSettings();
publicSettings.WmfVersion = string.IsNullOrEmpty(WmfVersion) ? "latest" : WmfVersion;
if (!string.IsNullOrEmpty(ArchiveBlobName))
{
ConfigurationUris configurationUris = UploadConfigurationDataToBlob();
publicSettings.SasToken = configurationUris.SasToken;
publicSettings.ModulesUrl = configurationUris.ModulesUrl;
publicSettings.ConfigurationFunction = string.Format(
CultureInfo.InvariantCulture,
"{0}\\{1}",
Path.GetFileNameWithoutExtension(ArchiveBlobName),
ConfigurationName);
Tuple <DscExtensionPublicSettings.Property[], Hashtable> settings =
DscExtensionSettingsSerializer.SeparatePrivateItems(ConfigurationArgument);
publicSettings.Properties = settings.Item1;
privateSettings.Items = settings.Item2;
privateSettings.DataBlobUri = configurationUris.DataBlobUri;
}
if (string.IsNullOrEmpty(this.Location))
{
this.Location = GetLocationFromVm(this.ResourceGroupName, this.VMName);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Name = Name ?? DscExtensionCmdletConstants.ExtensionPublishedNamespace + "." + DscExtensionCmdletConstants.ExtensionPublishedName,
Type = VirtualMachineExtensionType,
Publisher = DscExtensionCmdletConstants.ExtensionPublishedNamespace,
ExtensionType = DscExtensionCmdletConstants.ExtensionPublishedName,
TypeHandlerVersion = Version,
// Define the public and private property bags that will be passed to the extension.
Settings = DscExtensionSettingsSerializer.SerializePublicSettings(publicSettings),
//PrivateConfuguration contains sensitive data in a plain text
ProtectedSettings = DscExtensionSettingsSerializer.SerializePrivateSettings(privateSettings),
AutoUpgradeMinorVersion = AutoUpdate.IsPresent
};
//Add retry logic due to CRP service restart known issue CRP bug: 3564713
var count = 1;
ComputeLongRunningOperationResponse op = null;
while (count <= 2)
{
op = VirtualMachineExtensionClient.CreateOrUpdate(
ResourceGroupName,
VMName,
parameters);
if (ComputeOperationStatus.Failed.Equals(op.Status) && op.Error != null && "InternalExecutionError".Equals(op.Error.Code))
{
count++;
}
else
{
break;
}
}
var result = Mapper.Map <PSComputeLongRunningOperation>(op);
WriteObject(result);
}
/// <summary>
/// The Get Operation Status operation returns the status of the
/// specified operation. After calling an asynchronous operation, you
/// can call GetLongRunningOperationStatus to determine whether the
/// operation has succeeded, failed, or is still in progress.
/// </summary>
/// <param name='operationStatusLink'>
/// Required. Location value returned by the Begin operation.
/// </param>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
/// <returns>
/// The Compute service response for long-running operations.
/// </returns>
public async Task <ComputeLongRunningOperationResponse> GetLongRunningOperationStatusAsync(string operationStatusLink, CancellationToken cancellationToken)
{
// Validate
if (operationStatusLink == null)
{
throw new ArgumentNullException("operationStatusLink");
}
// Tracing
bool shouldTrace = TracingAdapter.IsEnabled;
string invocationId = null;
if (shouldTrace)
{
invocationId = TracingAdapter.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("operationStatusLink", operationStatusLink);
TracingAdapter.Enter(invocationId, this, "GetLongRunningOperationStatusAsync", tracingParameters);
}
// Construct URL
string url = "";
url = url + operationStatusLink;
url = url.Replace(" ", "%20");
// Create HTTP transport objects
HttpRequestMessage httpRequest = null;
try
{
httpRequest = new HttpRequestMessage();
httpRequest.Method = HttpMethod.Get;
httpRequest.RequestUri = new Uri(url);
// Set Headers
// Set Credentials
cancellationToken.ThrowIfCancellationRequested();
await this.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
// Send Request
HttpResponseMessage httpResponse = null;
try
{
if (shouldTrace)
{
TracingAdapter.SendRequest(invocationId, httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
httpResponse = await this.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
if (shouldTrace)
{
TracingAdapter.ReceiveResponse(invocationId, httpResponse);
}
HttpStatusCode statusCode = httpResponse.StatusCode;
if (statusCode != HttpStatusCode.OK && statusCode != HttpStatusCode.Accepted)
{
cancellationToken.ThrowIfCancellationRequested();
CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
if (shouldTrace)
{
TracingAdapter.Error(invocationId, ex);
}
throw ex;
}
// Create Result
ComputeLongRunningOperationResponse result = null;
// Deserialize Response
if (statusCode == HttpStatusCode.OK || statusCode == HttpStatusCode.Accepted)
{
cancellationToken.ThrowIfCancellationRequested();
string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
result = new ComputeLongRunningOperationResponse();
JToken responseDoc = null;
if (string.IsNullOrEmpty(responseContent) == false)
{
responseDoc = JToken.Parse(responseContent);
}
if (responseDoc != null && responseDoc.Type != JTokenType.Null)
{
JToken operationIdValue = responseDoc["operationId"];
if (operationIdValue != null && operationIdValue.Type != JTokenType.Null)
{
string operationIdInstance = ((string)operationIdValue);
result.TrackingOperationId = operationIdInstance;
}
JToken statusValue = responseDoc["status"];
if (statusValue != null && statusValue.Type != JTokenType.Null)
{
ComputeOperationStatus statusInstance = ((ComputeOperationStatus)Enum.Parse(typeof(ComputeOperationStatus), ((string)statusValue), true));
result.Status = statusInstance;
}
JToken startTimeValue = responseDoc["startTime"];
if (startTimeValue != null && startTimeValue.Type != JTokenType.Null)
{
DateTimeOffset startTimeInstance = ((DateTimeOffset)startTimeValue);
result.StartTime = startTimeInstance;
}
JToken endTimeValue = responseDoc["endTime"];
if (endTimeValue != null && endTimeValue.Type != JTokenType.Null)
{
DateTimeOffset endTimeInstance = ((DateTimeOffset)endTimeValue);
result.EndTime = endTimeInstance;
}
JToken propertiesValue = responseDoc["properties"];
if (propertiesValue != null && propertiesValue.Type != JTokenType.Null)
{
JToken outputValue = propertiesValue["output"];
if (outputValue != null && outputValue.Type != JTokenType.Null)
{
string outputInstance = outputValue.ToString(Newtonsoft.Json.Formatting.Indented);
result.Output = outputInstance;
}
}
JToken errorValue = responseDoc["error"];
if (errorValue != null && errorValue.Type != JTokenType.Null)
{
ApiError errorInstance = new ApiError();
result.Error = errorInstance;
JToken detailsArray = errorValue["details"];
if (detailsArray != null && detailsArray.Type != JTokenType.Null)
{
foreach (JToken detailsValue in ((JArray)detailsArray))
{
ApiErrorBase apiErrorBaseInstance = new ApiErrorBase();
errorInstance.Details.Add(apiErrorBaseInstance);
JToken codeValue = detailsValue["code"];
if (codeValue != null && codeValue.Type != JTokenType.Null)
{
string codeInstance = ((string)codeValue);
apiErrorBaseInstance.Code = codeInstance;
}
JToken targetValue = detailsValue["target"];
if (targetValue != null && targetValue.Type != JTokenType.Null)
{
string targetInstance = ((string)targetValue);
apiErrorBaseInstance.Target = targetInstance;
}
JToken messageValue = detailsValue["message"];
if (messageValue != null && messageValue.Type != JTokenType.Null)
{
string messageInstance = ((string)messageValue);
apiErrorBaseInstance.Message = messageInstance;
}
}
}
JToken innererrorValue = errorValue["innererror"];
if (innererrorValue != null && innererrorValue.Type != JTokenType.Null)
{
InnerError innererrorInstance = new InnerError();
errorInstance.InnerError = innererrorInstance;
JToken exceptiontypeValue = innererrorValue["exceptiontype"];
if (exceptiontypeValue != null && exceptiontypeValue.Type != JTokenType.Null)
{
string exceptiontypeInstance = ((string)exceptiontypeValue);
innererrorInstance.ExceptionType = exceptiontypeInstance;
}
JToken errordetailValue = innererrorValue["errordetail"];
if (errordetailValue != null && errordetailValue.Type != JTokenType.Null)
{
string errordetailInstance = ((string)errordetailValue);
innererrorInstance.ErrorDetail = errordetailInstance;
}
}
JToken codeValue2 = errorValue["code"];
if (codeValue2 != null && codeValue2.Type != JTokenType.Null)
{
string codeInstance2 = ((string)codeValue2);
errorInstance.Code = codeInstance2;
}
JToken targetValue2 = errorValue["target"];
if (targetValue2 != null && targetValue2.Type != JTokenType.Null)
{
string targetInstance2 = ((string)targetValue2);
errorInstance.Target = targetInstance2;
}
JToken messageValue2 = errorValue["message"];
if (messageValue2 != null && messageValue2.Type != JTokenType.Null)
{
string messageInstance2 = ((string)messageValue2);
errorInstance.Message = messageInstance2;
}
}
}
}
result.StatusCode = statusCode;
if (httpResponse.Headers.Contains("x-ms-request-id"))
{
result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
if (shouldTrace)
{
TracingAdapter.Exit(invocationId, result);
}
return(result);
}
finally
{
if (httpResponse != null)
{
httpResponse.Dispose();
}
}
}
finally
{
if (httpRequest != null)
{
httpRequest.Dispose();
}
}
}
public void TestVMOperations()
{
using (var context = UndoContext.Current)
{
context.Start();
EnsureClientsInitialized();
string imgRefId = GetPlatformOSImage(useWindowsImage: true);
// Create resource group
string rg1Name = TestUtilities.GenerateName(TestPrefix) + 1;
string asName = TestUtilities.GenerateName("as");
string storageAccountName = TestUtilities.GenerateName(TestPrefix);
VirtualMachine inputVM1;
bool passed = false;
try
{
// Create Storage Account, so that both the VMs can share it
var storageAccountOutput = CreateStorageAccount(rg1Name, storageAccountName);
VirtualMachine vm1 = CreateVM(rg1Name, asName, storageAccountOutput, imgRefId, out inputVM1);
var startOperationResponse = m_CrpClient.VirtualMachines.BeginStarting(rg1Name, vm1.Name);
Assert.Equal(HttpStatusCode.Accepted, startOperationResponse.StatusCode);
ComputeLongRunningOperationResponse lroResponse = m_CrpClient.VirtualMachines.Start(rg1Name, vm1.Name);
Assert.Equal(ComputeOperationStatus.Succeeded, lroResponse.Status);
var stopOperationResponse = m_CrpClient.VirtualMachines.BeginPoweringOff(rg1Name, vm1.Name);
Assert.Equal(HttpStatusCode.Accepted, startOperationResponse.StatusCode);
lroResponse = m_CrpClient.VirtualMachines.PowerOff(rg1Name, vm1.Name);
Assert.Equal(ComputeOperationStatus.Succeeded, lroResponse.Status);
var restartOperationResponse = m_CrpClient.VirtualMachines.BeginRestarting(rg1Name, vm1.Name);
Assert.Equal(HttpStatusCode.Accepted, startOperationResponse.StatusCode);
lroResponse = m_CrpClient.VirtualMachines.Restart(rg1Name, vm1.Name);
Assert.Equal(ComputeOperationStatus.Succeeded, lroResponse.Status);
var deallocateOperationResponse = m_CrpClient.VirtualMachines.BeginDeallocating(rg1Name, vm1.Name);
Assert.Equal(HttpStatusCode.Accepted, startOperationResponse.StatusCode);
lroResponse = m_CrpClient.VirtualMachines.Deallocate(rg1Name, vm1.Name);
Assert.Equal(ComputeOperationStatus.Succeeded, lroResponse.Status);
var generalizeResponse = m_CrpClient.VirtualMachines.Generalize(rg1Name, vm1.Name);
Assert.Equal(HttpStatusCode.OK, generalizeResponse.StatusCode);
var captureParams = new VirtualMachineCaptureParameters
{
DestinationContainerName = TestUtilities.GenerateName(TestPrefix),
VirtualHardDiskNamePrefix = TestUtilities.GenerateName(TestPrefix),
Overwrite = true
};
ComputeLongRunningOperationResponse captureResponse =
m_CrpClient.VirtualMachines.Capture(rg1Name, vm1.Name, captureParams);
Assert.Equal(ComputeOperationStatus.Succeeded, captureResponse.Status);
Assert.NotNull(captureResponse.Output);
string outputAsString = captureResponse.Output;
Assert.Equal('{', outputAsString[0]);
Assert.True(outputAsString.Contains(captureParams.DestinationContainerName.ToLowerInvariant()));
Assert.True(outputAsString.ToLowerInvariant().Contains(
captureParams.VirtualHardDiskNamePrefix.ToLowerInvariant()));
passed = true;
}
finally
{
// Cleanup the created resources. But don't wait since it takes too long, and it's not the purpose
// of the test to cover deletion. CSM does persistent retrying over all RG resources.
var deleteRg1Response = m_ResourcesClient.ResourceGroups.BeginDeleting(rg1Name);
Assert.True(deleteRg1Response.StatusCode == HttpStatusCode.Accepted, "BeginDeleting status was not Accepted.");
}
Assert.True(passed);
}
}
/// <summary>
/// we only support the Linux box now, if it's a windows, one AzureVMBackupException would be thrown.
/// </summary>
/// <param name="resourceGroupName"></param>
/// <param name="vmName"></param>
/// <param name="virtualMachineExtensionType"></param>
/// <param name="location"></param>
/// <param name="virtualMachineResponse"></param>
/// <param name="snapshotTag"></param>
/// <param name="virtualMachineExtensionBaseCmdlet"></param>
public void CreateSnapshotForDisks(AzureVMBackupConfig vmConfig, string snapshotTag, VirtualMachineExtensionBaseCmdlet virtualMachineExtensionBaseCmdlet)
{
VirtualMachine virtualMachine = virtualMachineExtensionBaseCmdlet.ComputeClient.ComputeManagementClient.VirtualMachines.GetWithInstanceView(vmConfig.ResourceGroupName, vmConfig.VMName).VirtualMachine;
StorageManagementClient storageClient = AzureSession.ClientFactory.CreateClient <StorageManagementClient>(virtualMachineExtensionBaseCmdlet.DefaultProfile.Context, AzureEnvironment.Endpoint.ResourceManager);
StorageCredentialsFactory storageCredentialsFactory = new StorageCredentialsFactory(vmConfig.ResourceGroupName, storageClient, virtualMachineExtensionBaseCmdlet.DefaultProfile.Context.Subscription);
CloudPageBlobObjectFactory cloudPageBlobObjectFactory = new CloudPageBlobObjectFactory(storageCredentialsFactory, TimeSpan.FromMinutes(1));
List <string> vmPageBlobUris = this.GetDiskBlobUris(virtualMachine);
AzureVMBackupBlobSasUris blobSASUris = this.GenerateBlobSasUris(vmPageBlobUris, cloudPageBlobObjectFactory);
string taskId = Guid.NewGuid().ToString();
AzureVMBackupExtensionProtectedSettings privateConfig = new AzureVMBackupExtensionProtectedSettings();
privateConfig.logsBlobUri = string.Empty;
privateConfig.objectStr = this.GetBase64Encoding(blobSASUris);
AzureVMBackupExtensionPublicSettings publicConfig = new AzureVMBackupExtensionPublicSettings();
publicConfig.commandToExecute = backupSnapshotCommand;
publicConfig.locale = backupDefaultLocale;
publicConfig.commandStartTimeUTCTicks = DateTimeOffset.UtcNow.Ticks.ToString();
publicConfig.taskId = taskId;
AzureVMBackupMetadata backupMetadata = new AzureVMBackupMetadata();
AzureVMBackupMetadataItem tagMetadataItem = new AzureVMBackupMetadataItem();
tagMetadataItem.Key = backupExtensionMetadataName;
tagMetadataItem.Value = snapshotTag;
AzureVMBackupMetadataItem taskIdMetadataItem = new AzureVMBackupMetadataItem();
taskIdMetadataItem.Key = backupExtensionIdentityMetadataName;
taskIdMetadataItem.Value = taskId;
backupMetadata.backupMetadata.Add(tagMetadataItem);
backupMetadata.backupMetadata.Add(taskIdMetadataItem);
publicConfig.objectStr = this.GetBase64Encoding(backupMetadata);
string publicSettingString = JsonConvert.SerializeObject(publicConfig);
string ProtectedSettingString = JsonConvert.SerializeObject(privateConfig);
VirtualMachineExtension vmExtensionParameters = new VirtualMachineExtension
{
Location = virtualMachine.Location,
Name = vmConfig.ExtensionName ?? backupExtensionName,
Type = vmConfig.VirtualMachineExtensionType,
Publisher = extensionPublisher,
ExtensionType = extensionType,
TypeHandlerVersion = extensionDefaultVersion,
Settings = publicSettingString,
ProtectedSettings = ProtectedSettingString,
};
ComputeLongRunningOperationResponse vmBackupOperation = virtualMachineExtensionBaseCmdlet.VirtualMachineExtensionClient.CreateOrUpdate(vmConfig.ResourceGroupName, vmConfig.VMName, vmExtensionParameters);
// check the snapshots with the task id are all created.
int timePeriod = 5000;
int loopingTimes = ((int)TimeSpan.FromMinutes(10).TotalMilliseconds / timePeriod);
Dictionary <string, string> snapshotQuery = new Dictionary <string, string>();
snapshotQuery.Add(backupExtensionMetadataName, snapshotTag);
snapshotQuery.Add(backupExtensionIdentityMetadataName, taskId);
int i = 0;
for (; i < loopingTimes; i++)
{
List <CloudPageBlob> snapshotsFound = this.FindSnapshot(vmPageBlobUris, snapshotQuery, storageCredentialsFactory);
if (snapshotsFound.Count == vmPageBlobUris.Count)
{
break;
}
else
{
Thread.Sleep(timePeriod);
}
}
if (i == loopingTimes)
{
throw new AzureVMBackupException(AzureVMBackupErrorCodes.TimeOut, "snapshot not created, or not found in time.");
}
}
