public override void ProcessRequest(HttpContext context)
{
try
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
string json;
bool isJsonP = context.Request.HttpMethod == "GET";
if (isJsonP)
{
json = context.Request.Params["data"];
}
else
{
json = new StreamReader(context.Request.InputStream).ReadToEnd();
}
GetImageUrlsParameters parameters = serializer.Deserialize <GetImageUrlsParameters>(json);
OperationStatusResponse data = GetImageUrls(_urlsCreator, parameters);
string serializedData = serializer.Serialize(data);
CreateJsonOrJsonpResponse(context, serializedData);
}
catch (Exception exception)
{
OnException(exception, context);
}
}
public void Undo()
{
string currentNetworkConfiguration = GetConfigurationSafe();
if (oldNetworkConfiguration != currentNetworkConfiguration)
{
bool setConfigurationComplete = false;
while (setConfigurationComplete == false)
{
try
{
OperationStatusResponse setConfigurationResponse = networkClient.Networks.SetConfiguration(new NetworkSetConfigurationParameters()
{
Configuration = oldNetworkConfiguration,
});
if (setConfigurationResponse.HttpStatusCode == HttpStatusCode.OK)
{
setConfigurationComplete = true;
}
}
catch (Hyak.Common.CloudException e)
{
if (e.Error.Code != "BadRequest")
{
throw;
}
}
}
}
}
protected OperationStatusResponse GetOperation(string operationId)
{
OperationStatusResponse operation = null;
try
{
operation = this.ManagementClient.GetOperationStatus(operationId);
if (operation.Status == OperationStatus.Failed)
{
var errorMessage = string.Format(CultureInfo.InvariantCulture, "{0}: {1}", operation.Status, operation.Error.Message);
throw new Exception(errorMessage);
}
}
catch (AggregateException ex)
{
if (ex.InnerException is CloudException)
{
WriteExceptionError(ex.InnerException);
}
else
{
WriteExceptionError(ex);
}
}
catch (Exception ex)
{
WriteExceptionError(ex);
}
return(operation);
}
public async Task <IActionResult> GetStatusAsync(Guid operationId)
{
_logger.LogInformation("DICOM Web Get Operation Status request received for ID '{OperationId}'", operationId);
OperationStatusResponse response = await _mediator.GetOperationStatusAsync(operationId, HttpContext.RequestAborted);
if (response == null)
{
return(NotFound());
}
HttpStatusCode statusCode;
OperationStatus operationStatus = response.OperationStatus;
if (operationStatus.Status == OperationRuntimeStatus.NotStarted || operationStatus.Status == OperationRuntimeStatus.Running)
{
Response.AddLocationHeader(_urlResolver.ResolveOperationStatusUri(operationId));
statusCode = HttpStatusCode.Accepted;
}
else
{
statusCode = HttpStatusCode.OK;
}
return(StatusCode((int)statusCode, operationStatus));
}
public async Task EgressCancelTest()
{
await ScenarioRunner.SingleTarget(
_outputHelper,
_httpClientFactory,
DiagnosticPortConnectionMode.Connect,
TestAppScenarios.AsyncWait.Name,
appValidate : async(appRunner, apiClient) =>
{
int processId = await appRunner.ProcessIdTask;
OperationResponse response = await apiClient.EgressTraceAsync(processId, durationSeconds: -1, FileProviderName);
Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
OperationStatusResponse operationResult = await apiClient.GetOperationStatus(response.OperationUri);
Assert.Equal(HttpStatusCode.OK, operationResult.StatusCode);
Assert.True(operationResult.OperationStatus.Status == OperationState.Running);
HttpStatusCode deleteStatus = await apiClient.CancelEgressOperation(response.OperationUri);
Assert.Equal(HttpStatusCode.OK, deleteStatus);
operationResult = await apiClient.GetOperationStatus(response.OperationUri);
Assert.Equal(HttpStatusCode.OK, operationResult.StatusCode);
Assert.Equal(OperationState.Cancelled, operationResult.OperationStatus.Status);
await appRunner.SendCommandAsync(TestAppScenarios.AsyncWait.Commands.Continue);
},
configureTool : (toolRunner) =>
{
toolRunner.WriteKeyPerValueConfiguration(new RootOptions().AddFileSystemEgress(FileProviderName, _tempDirectory.FullName));
});
}
//TODO: Input argument is not used and should probably be removed.
protected void ExecuteClientActionNewSM <TResult>(object input, string operationDescription, Func <TResult> action, Func <OperationStatusResponse, TResult, object> contextFactory) where TResult : AzureOperationResponse
{
WriteVerboseWithTimestamp(Resources.ServiceManagementExecuteClientActionInOCSBeginOperation, operationDescription);
try
{
try
{
TResult result = action();
OperationStatusResponse operation = GetOperation(result);
var context = contextFactory(operation, result);
if (context != null)
{
WriteObject(context, true);
}
}
catch (CloudException ce)
{
throw new ComputeCloudException(ce);
}
}
catch (Exception ex)
{
WriteExceptionError(ex);
}
WriteVerboseWithTimestamp(Resources.ServiceManagementExecuteClientActionInOCSCompletedOperation, operationDescription);
}
public async Task EgressListTest()
{
await ScenarioRunner.SingleTarget(
_outputHelper,
_httpClientFactory,
DiagnosticPortConnectionMode.Connect,
TestAppScenarios.AsyncWait.Name,
appValidate : async(appRunner, apiClient) =>
{
int processId = await appRunner.ProcessIdTask;
OperationResponse response1 = await EgressTraceWithDelay(apiClient, processId);
OperationResponse response2 = await EgressTraceWithDelay(apiClient, processId, delay: false);
await CancelEgressOperation(apiClient, response2);
List <OperationSummary> result = await apiClient.GetOperations();
Assert.Equal(2, result.Count);
OperationStatusResponse status1 = await apiClient.GetOperationStatus(response1.OperationUri);
OperationSummary summary1 = result.First(os => os.OperationId == status1.OperationStatus.OperationId);
ValidateOperation(status1.OperationStatus, summary1);
OperationStatusResponse status2 = await apiClient.GetOperationStatus(response2.OperationUri);
OperationSummary summary2 = result.First(os => os.OperationId == status2.OperationStatus.OperationId);
ValidateOperation(status2.OperationStatus, summary2);
await appRunner.SendCommandAsync(TestAppScenarios.AsyncWait.Commands.Continue);
},
configureTool : (toolRunner) =>
{
toolRunner.WriteKeyPerValueConfiguration(new RootOptions().AddFileSystemEgress(FileProviderName, _tempDirectory.FullName));
});
}
public static void CreateAzureVirtualMachine(ComputeManagementClient computeClient, string serviceName, string deploymentName, string storageAccountName, string blobUrl)
{
VirtualMachineOSImageListResponse imagesList = computeClient.VirtualMachineOSImages.List();
VirtualMachineOSImageListResponse.VirtualMachineOSImage imageToGet =
imagesList.Images.FirstOrDefault(i => string.Equals(i.OperatingSystemType, "Windows", StringComparison.OrdinalIgnoreCase));
VirtualMachineOSImageGetResponse gottenImage = computeClient.VirtualMachineOSImages.Get(imageToGet.Name);
VirtualMachineCreateDeploymentParameters parameters = CreateVMParameters(gottenImage, deploymentName, storageAccountName, "SampleLabel", blobUrl);
parameters.Roles[0].ConfigurationSets.Add(new ConfigurationSet
{
AdminUserName = "******",
AdminPassword = GetRandomPassword(),
ConfigurationSetType = ConfigurationSetTypes.WindowsProvisioningConfiguration,
ComputerName = serviceName,
HostName = string.Format("{0}.cloudapp.net", serviceName),
EnableAutomaticUpdates = false,
TimeZone = "Pacific Standard Time"
});
OperationStatusResponse opResp =
computeClient.VirtualMachines.CreateDeployment(serviceName, parameters);
Assert.Equal(opResp.Status, OperationStatus.Succeeded);
}
private static string StartVMs(SubscriptionCloudCredentials creds, RootStartVMsObject root, Subscription sub, TextWriter log)
{
List <string> roles = new List <string>();
foreach (JSONStartVMsVM vm in root.startvms.VM)
{
roles.Add(vm.Name);
}
try
{
using (var client = new ComputeManagementClient(creds))
{
OperationStatusResponse resp = client.VirtualMachines.StartRoles(
root.startvms.Service.ServiceName,
root.startvms.Service.DeploymentName,
new VirtualMachineStartRolesParameters
{
Roles = roles
});
return(resp.RequestId);
}
}
catch (Exception ex)
{
// get a 404 if the cloud service doesn't exist
string msg = string.Format("Exception starting VMs: {0}", ex.Message);
Common.LogExit(msg, root.startvms.Service.ServiceName, log);
return(null);
}
}
protected override void OnProcessRecord()
{
ServiceManagementPlatformImageRepositoryProfile.Initialize();
ExecuteClientActionNewSM(
null,
CommandRuntime.ToString(),
() =>
{
OperationStatusResponse op = null;
bool found = ExtensionExists();
var publishCnfm = Resources.ExtensionPublishingConfirmation;
var publishCptn = Resources.ExtensionPublishingCaption;
var upgradeCnfm = Resources.ExtensionUpgradingConfirmation;
var upgradeCptn = Resources.ExtensionUpgradingCaption;
this.IsInternalExtension = true;
if (found && (this.Force.IsPresent || this.ShouldContinue(upgradeCnfm, upgradeCptn)))
{
var parameters = ServiceManagementPlatformImageRepositoryProfile.Mapper.Map <ExtensionImageUpdateParameters>(this);
op = this.ComputeClient.ExtensionImages.Update(parameters);
}
else if (!found && (this.Force.IsPresent || this.ShouldContinue(publishCnfm, publishCptn)))
{
var parameters = ServiceManagementPlatformImageRepositoryProfile.Mapper.Map <ExtensionImageRegisterParameters>(this);
op = this.ComputeClient.ExtensionImages.Register(parameters);
}
return(op);
});
}
public void AssociateReservedIP(
string usWestLocStr,
string location,
string storageAccountName,
ref bool storageAccountCreated,
string serviceName,
string deploymentName,
string reserveIpName,
ref bool hostedServiceCreated,
ref bool reserveIpCreated)
{
if (this.ManagementClient.Locations.List().Any(
c => string.Equals(c.Name, usWestLocStr, StringComparison.OrdinalIgnoreCase)))
{
location = usWestLocStr;
}
this.CreateStorageAccount(location, storageAccountName, out storageAccountCreated);
this.CreateHostedService(location, serviceName, out hostedServiceCreated);
this.CreatePaaSDeployment(storageAccountName, serviceName, deploymentName, NetworkTestConstants.OneWebOneWorkerPkgFilePath, "OneWebOneWorker.cscfg", true);
NetworkReservedIPCreateParameters reservedIpCreatePars = new NetworkReservedIPCreateParameters
{
Name = reserveIpName,
Location = location,
Label = "SampleReserveIPLabel",
};
OperationStatusResponse reserveIpCreate = this.NetworkClient.ReservedIPs.Create(reservedIpCreatePars);
Assert.True(reserveIpCreate.StatusCode == HttpStatusCode.OK);
reserveIpCreated = true;
NetworkReservedIPGetResponse reserveIpCreationResponse =
this.NetworkClient.ReservedIPs.Get(reserveIpName);
Assert.True(reserveIpCreationResponse.StatusCode == HttpStatusCode.OK);
NetworkReservedIPMobilityParameters pars = new NetworkReservedIPMobilityParameters
{
ServiceName = serviceName,
DeploymentName = deploymentName
};
OperationStatusResponse responseAssociateRip = this.NetworkClient.ReservedIPs.Associate(reserveIpName, pars);
Assert.True(responseAssociateRip.StatusCode == HttpStatusCode.OK);
NetworkReservedIPGetResponse receivedReservedIpFromRdfe =
this.NetworkClient.ReservedIPs.Get(reserveIpName);
Assert.True(receivedReservedIpFromRdfe.StatusCode == HttpStatusCode.OK);
Assert.True(serviceName == receivedReservedIpFromRdfe.ServiceName);
Assert.True(receivedReservedIpFromRdfe.InUse == true);
Assert.True(deploymentName == receivedReservedIpFromRdfe.DeploymentName);
}
public void CanAbortVirtualMachineDeployment()
{
TestUtilities.StartTest();
using (fixture.ComputeClient = fixture.GetComputeManagementClient())
{
var serviceName = TestUtilities.GenerateName();
var result = fixture.ComputeClient.HostedServices.Create(new HostedServiceCreateParameters
{
Location = fixture.Location,
Label = serviceName,
ServiceName = serviceName
});
// assert that the call worked
Assert.Equal(result.StatusCode, HttpStatusCode.Created);
VirtualMachineOSImageListResponse imagesList = fixture.ComputeClient.VirtualMachineOSImages.List();
VirtualMachineOSImageListResponse.VirtualMachineOSImage imageToGet =
imagesList.Images.FirstOrDefault(i => string.Equals(i.OperatingSystemType, "Windows", StringComparison.OrdinalIgnoreCase));
VirtualMachineOSImageGetResponse gottenImage = fixture.ComputeClient.VirtualMachineOSImages.Get(imageToGet.Name);
VirtualMachineCreateDeploymentParameters parameters = CreateVMParameters(gottenImage, serviceName);
parameters.Roles[0].ConfigurationSets.Add(new ConfigurationSet
{
AdminUserName = "******",
AdminPassword = ComputeTestsUtilities.GenerateRandomPassword(),
ConfigurationSetType = ConfigurationSetTypes.WindowsProvisioningConfiguration,
ComputerName = serviceName,
HostName = string.Format("{0}.cloudapp.net", serviceName),
EnableAutomaticUpdates = false,
TimeZone = "Pacific Standard Time"
});
OperationStatusResponse opResp =
fixture.ComputeClient.VirtualMachines.CreateDeployment(serviceName, parameters);
Assert.Equal(opResp.Status, OperationStatus.Succeeded);
var prepareParameters = new PrepareDeploymentMigrationParameters
{
DestinationVirtualNetwork = "New",
ResourceGroupName = string.Empty,
SubNetName = string.Empty,
VirtualNetworkName = string.Empty
};
opResp = fixture.ComputeClient.Deployments.PrepareMigration(serviceName, parameters.Name, prepareParameters);
Assert.Equal(opResp.Status, OperationStatus.Succeeded);
opResp = fixture.ComputeClient.Deployments.AbortMigration(serviceName, parameters.Name);
Assert.Equal(opResp.Status, OperationStatus.Succeeded);
}
TestUtilities.EndTest();
}
protected T2 ContextFactory <T1, T2>(T1 source, OperationStatusResponse response) where T2 : ManagementOperationContext
{
var context = Mapper.Map <T1, T2>(source);
context = Mapper.Map(response, context);
context.OperationDescription = CommandRuntime.ToString();
return(context);
}
private void PopulateOperationContext(string requestId, IEnumerable <ManagementOperationContext> operationContexts)
{
OperationStatusResponse operationStatus = managementClient.GetOperationStatus(requestId);
foreach (ManagementOperationContext operationContext in operationContexts)
{
PopulateOperationContext(operationStatus, operationContext);
}
}
protected TDestination ContextFactory <TSource, TDestination>(TSource s1, OperationStatusResponse s2) where TDestination : ManagementOperationContext
{
TDestination result = Mapper.Map <TSource, TDestination>(s1);
result = Mapper.Map(s2, result);
result.OperationDescription = CommandRuntime.ToString();
return(result);
}
protected void ExecuteClientActionNewSM <TResult>(object input, string operationDescription, Func <TResult> action, Func <string, string, OperationStatusResponse> waitOperation, Func <OperationStatusResponse, TResult, object> contextFactory) where TResult : OperationResponse
{
TResult result = null;
OperationStatusResponse operation = null;
WriteVerboseWithTimestamp(string.Format(Resources.ServiceManagementExecuteClientActionInOCSBeginOperation, operationDescription));
try
{
try
{
result = action();
}
catch (CloudException ex)
{
WriteExceptionDetails(ex);
}
if (result is OperationStatusResponse)
{
operation = result as OperationStatusResponse;
}
else
{
if (waitOperation == null)
{
operation = result == null ? null : GetOperationNewSM(result.RequestId);
}
else
{
operation = result == null ? null : waitOperation(result.RequestId, operationDescription);
}
}
}
catch (AggregateException ex)
{
if (ex.InnerException is CloudException)
{
WriteExceptionDetails(ex.InnerException);
}
else
{
WriteExceptionDetails(ex);
}
}
WriteVerboseWithTimestamp(string.Format(Resources.ServiceManagementExecuteClientActionInOCSCompletedOperation, operationDescription));
if (result != null)
{
var context = contextFactory(operation, result);
if (context != null)
{
WriteObject(context, true);
}
}
}
public void StartVirtualMachine(string groupName, string vmName, string subscriptionId)
{
var token = GetAccessTokenAsync();
var credential = new TokenCredentials(token.AccessToken);
var computeManagementClient = new ComputeManagementClient(credential)
{
SubscriptionId = subscriptionId
};
OperationStatusResponse result = computeManagementClient.VirtualMachines.Start(groupName, vmName);
}
protected virtual ExtensionContext GetContext(OperationStatusResponse op, ExtensionRole role, HostedServiceListExtensionsResponse.Extension ext)
{
return(new ExtensionContext
{
OperationId = op.Id,
OperationDescription = CommandRuntime.ToString(),
OperationStatus = op.Status.ToString(),
Extension = ext.Type,
ProviderNameSpace = ext.ProviderNamespace,
Id = ext.Id
});
}
private static void AssociateReservedIP(ManagementClient managementClient, string usWestLocStr, string location,
StorageManagementClient storageClient, string storageAccountName, ref bool storageAccountCreated,
ComputeManagementClient computeClient, string serviceName, string deploymentName, string reserveIpName,
NetworkTestBase _testFixture, ref bool hostedServiceCreated, ref bool reserveIpCreated)
{
if (managementClient.Locations.List().Any(
c => string.Equals(c.Name, usWestLocStr, StringComparison.OrdinalIgnoreCase)))
{
location = usWestLocStr;
}
CreateStorageAccount(location, storageClient, storageAccountName, out storageAccountCreated);
CreateHostedService(location, computeClient, serviceName, out hostedServiceCreated);
CreatePaaSDeployment(storageAccountName, computeClient, serviceName, deploymentName);
NetworkReservedIPCreateParameters reservedIpCreatePars = new NetworkReservedIPCreateParameters
{
Name = reserveIpName,
Location = "uswest",
Label = "SampleReserveIPLabel"
};
OperationStatusResponse reserveIpCreate = _testFixture.NetworkClient.ReservedIPs.Create(reservedIpCreatePars);
Assert.True(reserveIpCreate.StatusCode == HttpStatusCode.OK);
reserveIpCreated = true;
NetworkReservedIPGetResponse reserveIpCreationResponse =
_testFixture.NetworkClient.ReservedIPs.Get(reserveIpName);
Assert.True(reserveIpCreationResponse.StatusCode == HttpStatusCode.OK);
NetworkReservedIPMobilityParameters pars = new NetworkReservedIPMobilityParameters
{
ServiceName = serviceName,
DeploymentName = deploymentName
};
OperationStatusResponse responseAssociateRip = _testFixture.NetworkClient.ReservedIPs.Associate(reserveIpName, pars);
Assert.True(responseAssociateRip.StatusCode == HttpStatusCode.OK);
NetworkReservedIPGetResponse receivedReservedIpFromRdfe =
_testFixture.NetworkClient.ReservedIPs.Get(reserveIpName);
Assert.True(receivedReservedIpFromRdfe.StatusCode == HttpStatusCode.OK);
Assert.True(serviceName == receivedReservedIpFromRdfe.ServiceName);
Assert.True(receivedReservedIpFromRdfe.InUse == true);
Assert.True(deploymentName == receivedReservedIpFromRdfe.DeploymentName);
}
protected TDestination ContextFactory <TSource, TDestination>(
TSource s1,
OperationStatusResponse s2,
Func <TSource, TDestination> firstMap,
Func <OperationStatusResponse, TDestination, TDestination> secondMap) where TDestination : ManagementOperationContext
{
TDestination result = firstMap(s1);
result = secondMap(s2, result);
result.OperationDescription = CommandRuntime.ToString();
return(result);
}
public void AbortSimpleVNetConfiguration()
{
using (NetworkTestClient networkTestClient = new NetworkTestClient())
{
OperationStatusResponse osResp = networkTestClient.SetNetworkConfiguration(NetworkTestConstants.SimpleMigrationNetworkConfigurationParameters);
Assert.Equal(OperationStatus.Succeeded, osResp.Status);
osResp = networkTestClient.PrepareVnetMigration(NetworkTestConstants.VirtualNetworkSiteName);
Assert.Equal(OperationStatus.Succeeded, osResp.Status);
osResp = networkTestClient.AbortVnetMigration(NetworkTestConstants.VirtualNetworkSiteName);
Assert.Equal(OperationStatus.Succeeded, osResp.Status);
}
}
public void TestReserveIPWithIPTagsNegative()
{
using (var undoContext = AZT.UndoContext.Current)
{
undoContext.Start();
using (NetworkTestBase _testFixture = new NetworkTestBase())
{
var managementClient = _testFixture.ManagementClient;
bool storageAccountCreated = false;
string storageAccountName = HttpMockServer.GetAssetName("tststr1234", "tststr").ToLower();
string reserveIpName = HttpMockServer.GetAssetName("res", "testresIPtagNegative").ToLower();
string location = managementClient.GetDefaultLocation("Storage", "Compute");
// Create an IPTag Value that doesn't exist
IPTag iptag = new IPTag();
iptag.IPTagType = "FirstPartyUsage";
iptag.Value = "MyVip";
List <IPTag> iptags = new List <IPTag>();
iptags.Add(iptag);
try
{
_testFixture.CreateStorageAccount(location, storageAccountName, out storageAccountCreated);
NetworkReservedIPCreateParameters reservedIpCreatePars = new NetworkReservedIPCreateParameters
{
Name = reserveIpName,
Label = "TestResTagNegLabel",
Location = location,
IPTags = iptags
};
OperationStatusResponse reserveIpCreate = _testFixture.NetworkClient.ReservedIPs.Create(reservedIpCreatePars);
}
catch (Exception ex)
{
Console.WriteLine("TestReserveIPWithIPTagsNegative test did not succeed with error being ," + ex.Message);
Assert.NotNull(ex);
}
finally
{
if (storageAccountCreated)
{
_testFixture.StorageClient.StorageAccounts.Delete(storageAccountName);
}
}
}
}
}
private DeploymentGetResponse GetCurrentDeployment(out OperationStatusResponse operation)
{
DeploymentSlot slot = string.IsNullOrEmpty(this.Slot) ?
DeploymentSlot.Production :
(DeploymentSlot)Enum.Parse(typeof(DeploymentSlot), this.Slot, true);
WriteVerboseWithTimestamp(Resources.GetDeploymentBeginOperation);
DeploymentGetResponse deploymentGetResponse = null;
InvokeInOperationContext(() => deploymentGetResponse = this.ComputeClient.Deployments.GetBySlot(this.ServiceName, slot));
operation = GetOperationNewSM(deploymentGetResponse.RequestId);
WriteVerboseWithTimestamp(Resources.GetDeploymentCompletedOperation);
return(deploymentGetResponse);
}
private DeploymentGetResponse GetCurrentDeployment(out OperationStatusResponse operation)
{
DeploymentSlot slot;
if (!Enum.TryParse(this.Slot, out slot))
{
throw new ArgumentOutOfRangeException("Slot");
}
WriteVerboseWithTimestamp(Resources.GetDeploymentBeginOperation);
DeploymentGetResponse deploymentGetResponse = this.ComputeClient.Deployments.GetBySlot(this.ServiceName, slot);
operation = GetOperationNewSM(deploymentGetResponse.RequestId);
WriteVerboseWithTimestamp(Resources.GetDeploymentCompletedOperation);
return(deploymentGetResponse);
}
/// <summary>
/// Get the status of an operation given a raw Operation Status Link
/// </summary>
/// <param name="operationStatusLink">Status link as returned by the import or export commandlet</param>
/// <param name="rawHttpResponse">Out parameter for the raw HTTP response for further inspection</param>
/// <returns></returns>
public ImportExportOperationResult GetOperationStatus(string operationStatusLink, out HttpResponseMessage rawHttpResponse)
{
var client = GetCurrentSqlClient();
HttpRequestMessage httpRequest = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri(operationStatusLink)
};
client.Credentials.ProcessHttpRequestAsync(httpRequest, CancellationToken.None).ConfigureAwait(false).GetAwaiter().GetResult();
var response = client.HttpClient.SendAsync(httpRequest, CancellationToken.None).ConfigureAwait(false).GetAwaiter().GetResult();
rawHttpResponse = response;
string responseString = response.Content.ReadAsStringAsync().Result;
if (response.IsSuccessStatusCode)
{
ImportExportOperationResult operationResult = JsonConvert.DeserializeObject <ImportExportOperationResult>(responseString, new JsonSerializerSettings
{
Converters = new List <JsonConverter>()
{
new Rest.Serialization.TransformationJsonConverter()
},
NullValueHandling = NullValueHandling.Ignore
});
return(operationResult);
}
else
{
OperationStatusResponse errorResult = JsonConvert.DeserializeObject <OperationStatusResponse>(responseString, new JsonSerializerSettings
{
Converters = new List <JsonConverter>()
{
new Rest.Serialization.TransformationJsonConverter()
},
NullValueHandling = NullValueHandling.Ignore
});
HttpRequestException ex = new HttpRequestException(errorResult.Error.Message);
throw ex;
}
}
private static void DisassociateReservedIP(NetworkTestBase _testFixture, string reserveIpName, string serviceName, string deploymentName)
{
NetworkReservedIPMobilityParameters pars = new NetworkReservedIPMobilityParameters
{
ServiceName = serviceName,
DeploymentName = deploymentName
};
OperationStatusResponse responseDisassociateRip = _testFixture.NetworkClient.ReservedIPs.Disassociate(reserveIpName, pars);
Assert.True(responseDisassociateRip.StatusCode == HttpStatusCode.OK);
NetworkReservedIPGetResponse receivedReservedIpFromRdfe =
_testFixture.NetworkClient.ReservedIPs.Get(reserveIpName);
Assert.True(receivedReservedIpFromRdfe.StatusCode == HttpStatusCode.OK);
Assert.True(string.IsNullOrEmpty(receivedReservedIpFromRdfe.ServiceName));
Assert.True(receivedReservedIpFromRdfe.InUse == false);
Assert.True(string.IsNullOrEmpty(receivedReservedIpFromRdfe.DeploymentName));
}
private static string DeleteDeployment(SubscriptionCloudCredentials creds, RootDeleteDeploymentObject root, Subscription sub, TextWriter log)
{
try
{
using (var client = new ComputeManagementClient(creds))
{
OperationStatusResponse resp = client.Deployments.DeleteBySlot(
root.deletedeployment.Service.ServiceName,
(DeploymentSlot)Enum.Parse(typeof(DeploymentSlot), root.deletedeployment.Service.Slot));
return(resp.RequestId);
}
}
catch (Exception ex)
{
// get a 404 if the cloud service doesn't exist
string msg = string.Format("Exception deleting deployment: {0}", ex.Message);
Common.LogExit(msg, root.deletedeployment.Service.ServiceName, log);
return(null);
}
}
public void AbortSimpleVNetConfiguration()
{
using (NetworkTestClient networkTestClient = new NetworkTestClient())
{
OperationStatusResponse osResp = networkTestClient.SetNetworkConfiguration(NetworkTestConstants.SimpleMigrationNetworkConfigurationParameters);
Assert.Equal(OperationStatus.Succeeded, osResp.Status);
osResp = networkTestClient.PrepareVnetMigration(NetworkTestConstants.VirtualNetworkSiteName);
Assert.Equal(OperationStatus.Succeeded, osResp.Status);
NetworkListResponse response = networkTestClient.ListNetworkConfigurations();
// BUG: Return "2" instead of "Prepared"
// Re-record after the bug is fixed in Server.
Assert.NotNull(response.VirtualNetworkSites.First().MigrationState);
//Assert.Equal(IaasClassicToArmMigrationState.Prepared, response.VirtualNetworkSites.First().MigrationState);
osResp = networkTestClient.AbortVnetMigration(NetworkTestConstants.VirtualNetworkSiteName);
Assert.Equal(OperationStatus.Succeeded, osResp.Status);
}
}
public void DeleteConfiguration()
{
using (NetworkTestClient networkTestClient = new NetworkTestClient())
{
networkTestClient.Gateways.EnsureNoGatewayExists();
OperationStatusResponse response = networkTestClient.SetNetworkConfiguration(NetworkTestConstants.EmptyNetworkConfigurationParameters);
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.HttpStatusCode);
try
{
networkTestClient.GetNetworkConfiguration();
}
catch (Hyak.Common.CloudException e)
{
Assert.Equal("ResourceNotFound", e.Error.Code);
}
}
}
public static MigrationValidateContext ConvertToContext(
OperationStatusResponse operationResponse, NetworkMigrationValidationResponse validationResponse)
{
if (operationResponse == null)
{
return(null);
}
var result = new MigrationValidateContext
{
OperationId = operationResponse.Id,
Result = operationResponse.Status.ToString()
};
if (validationResponse == null || validationResponse.ValidationMessages == null)
{
return(result);
}
var errorCount = validationResponse.ValidationMessages.Count;
if (errorCount > 0)
{
result.ValidationMessages = new ValidationMessage[errorCount];
for (int i = 0; i < errorCount; i++)
{
result.ValidationMessages[i] = new ValidationMessage
{
ResourceName = validationResponse.ValidationMessages[i].ResourceName,
ResourceType = validationResponse.ValidationMessages[i].ResourceType,
Category = validationResponse.ValidationMessages[i].Category,
Message = validationResponse.ValidationMessages[i].Message,
VirtualMachineName = validationResponse.ValidationMessages[i].VirtualMachineName
};
}
result.Result = "Validation failed. Please see ValidationMessages for details";
}
return(result);
}
private DeploymentGetResponse GetCurrentDeployment(out OperationStatusResponse operation)
{
DeploymentSlot slot;
if (!Enum.TryParse(this.Slot, out slot))
{
throw new ArgumentOutOfRangeException("Slot");
}
WriteVerboseWithTimestamp(Resources.GetDeploymentBeginOperation);
DeploymentGetResponse deploymentGetResponse = this.ComputeClient.Deployments.GetBySlot(this.ServiceName, slot);
operation = GetOperationNewSM(deploymentGetResponse.RequestId);
WriteVerboseWithTimestamp(Resources.GetDeploymentCompletedOperation);
return deploymentGetResponse;
}
protected virtual ExtensionContext GetContext(OperationStatusResponse op, ExtensionRole role, HostedServiceListExtensionsResponse.Extension ext)
{
return new ExtensionContext
{
OperationId = op.Id,
OperationDescription = CommandRuntime.ToString(),
OperationStatus = op.Status.ToString(),
Extension = ext.Type,
ProviderNameSpace = ext.ProviderNamespace,
Id = ext.Id
};
}
private DeploymentGetResponse GetCurrentDeployment(out OperationStatusResponse operation)
{
DeploymentSlot slot = string.IsNullOrEmpty(this.Slot) ? DeploymentSlot.Production :
(DeploymentSlot)Enum.Parse(typeof(DeploymentSlot), this.Slot, true);
WriteVerboseWithTimestamp(Resources.GetDeploymentBeginOperation);
DeploymentGetResponse deploymentGetResponse = null;
InvokeInOperationContext(() => deploymentGetResponse = this.ComputeClient.Deployments.GetBySlot(this.ServiceName, slot));
operation = GetOperationNewSM(deploymentGetResponse.RequestId);
WriteVerboseWithTimestamp(Resources.GetDeploymentCompletedOperation);
return deploymentGetResponse;
}
protected override ExtensionContext GetContext(OperationStatusResponse op, ExtensionRole role, HostedServiceListExtensionsResponse.Extension ext)
{
var config = Deserialize(ext.PublicConfiguration, typeof(PublicConfig)) as PublicConfig;
return new ADDomainExtensionContext
{
OperationId = op.Id,
OperationDescription = CommandRuntime.ToString(),
OperationStatus = op.Status.ToString(),
Extension = ext.Type,
ProviderNameSpace = ext.ProviderNamespace,
Id = ext.Id,
Role = role,
Name = config.Name,
OUPath = config.OUPath,
JoinOption = config.Options,
User = config.User,
UnjoinDomainUser = config.UnjoinDomainUser,
Restart = config.Restart
};
}
