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 }; }