public async Task <ResourceProvisioningResult> EnsureCreated(ResourceProvisioningParameters parameters, CancellationToken cancellationToken = default) { _logger.LogInformation($"Creating virtual network {parameters.Name} in resource Group: {parameters.ResourceGroupName}"); var networkSettings = CloudResourceConfigStringSerializer.NetworkSettings(parameters.ConfigurationString); var virtualNetwork = await GetResourceInternalAsync(parameters.ResourceGroupName, parameters.Name, false); if (virtualNetwork == null) { virtualNetwork = await CreateInternalAsync(GetRegionFromString(parameters.Region), parameters.ResourceGroupName, parameters.Name, networkSettings.SandboxSubnetName, parameters.Tags, cancellationToken); } if (!parameters.TryGetSharedVariable(AzureCrudSharedVariable.NETWORK_SECURITY_GROUP_NAME, out string networkSecurityGroupName)) { throw new ArgumentException("AzureVirtualNetworkService: Missing network security group name from input"); } await EnsureNetworkSecurityGroupIsAddedToSubnet(virtualNetwork, networkSecurityGroupName, networkSettings.SandboxSubnetName); _logger.LogInformation($"Done creating virtual network {parameters.Name}"); var crudResult = CreateResult(virtualNetwork); return(crudResult); }
public async Task <ResourceProvisioningResult> EnsureCreated(ResourceProvisioningParameters parameters, CancellationToken cancellationToken = default) { _logger.LogInformation($"Creating Bastion for sandbox with Name: {parameters.SandboxName}! Resource Group: {parameters.ResourceGroupName}"); if (!parameters.TryGetSharedVariable(AzureCrudSharedVariable.BASTION_SUBNET_ID, out string subnetId)) { throw new ArgumentException("AzureBastionService: Missing Bastion subnet ID from input"); } var bastionHost = await GetResourceInternalAsync(parameters.ResourceGroupName, parameters.Name, false); if (bastionHost == null) { bastionHost = await CreateInternal(GetRegionFromString(parameters.Region), parameters.ResourceGroupName, parameters.Name, subnetId, parameters.Tags, cancellationToken); _logger.LogInformation($"Done creating Bastion for sandbox with Id: {parameters.SandboxName}! Bastion Id: {bastionHost.Id}"); } else { _logger.LogInformation($"Ensure bastion exist for Sandbox: {parameters.SandboxName}! Bastion allready existed. Bastion Id: {bastionHost.Id}"); } var result = CreateResult(bastionHost); return(result); }
public async Task <ResourceProvisioningResult> Handle( CloudResourceOperationDto operation, ResourceProvisioningParameters currentCrudInput, IPerformResourceProvisioning provisioningService ) { try { _provisioningLogService.OperationInformation(operation, $"Deleting {operation.Resource.ResourceType}"); var deleteTask = provisioningService.EnsureDeleted(currentCrudInput); while (!deleteTask.IsCompleted) { operation = await _cloudResourceOperationUpdateService.TouchAsync(operation.Id); Thread.Sleep((int)TimeSpan.FromSeconds(3).TotalMilliseconds); } _provisioningLogService.OperationInformation(operation, $"Delete Operation finished"); return(deleteTask.Result); } catch (Exception ex) { throw new ProvisioningException($"Provisioning (Delete) failed", innerException: ex); } }
public async Task <ResourceProvisioningResult> GetSharedVariables(ResourceProvisioningParameters parameters) { var network = await GetResourceInternalAsync(parameters.ResourceGroupName, parameters.Name); var crudResult = CreateResult(network); return(crudResult); }
public async Task <ResourceProvisioningResult> EnsureDeleted(ResourceProvisioningParameters parameters) { await DeleteInternalAsync(parameters.ResourceGroupName, parameters.Name, parameters.NetworkSecurityGroupName, parameters.ConfigurationString); var provisioningState = await GetProvisioningState(parameters.ResourceGroupName, parameters.Name); return(ResourceProvisioningResultUtil.CreateFromProvisioningState(provisioningState)); }
public async Task <ResourceProvisioningResult> GetSharedVariables(ResourceProvisioningParameters parameters) { var vm = await GetInternalAsync(parameters.ResourceGroupName, parameters.Name); var result = CreateCRUDResult(vm); return(result); }
public async Task <ResourceProvisioningResult> GetSharedVariables(ResourceProvisioningParameters parameters) { var diagnosticStorageAccount = await GetResourceAsync(parameters.ResourceGroupName, parameters.Name); var result = CreateResult(diagnosticStorageAccount); return(result); }
public async Task <ResourceProvisioningResult> GetSharedVariables(ResourceProvisioningParameters parameters) { var resourceGroup = await GetResourceGroupAsync(parameters.Name); var crudResult = ResourceProvisioningResultUtil.CreateFromIResource(resourceGroup); crudResult.CurrentProvisioningState = resourceGroup.ProvisioningState.ToString(); return(crudResult); }
public async Task <ResourceProvisioningResult> EnsureDeleted(ResourceProvisioningParameters parameters) { await DeleteInternal(parameters.ResourceGroupName, parameters.Name); var provisioningState = await GetProvisioningState(parameters.ResourceGroupName, parameters.Name); var crudResult = ResourceProvisioningResultUtil.CreateFromProvisioningState(provisioningState); return(crudResult); }
async Task <int> FindNextPriority(ResourceProvisioningParameters parameters, Dictionary <string, NsgRuleDto> existingRulesForVm, int startingAt, int increaseBy, int highestAllowed, string direction, CancellationToken cancellationToken = default) { var existingRuleForSameVmWithHighestPriority = existingRulesForVm.Values.Where(r => r.Direction == direction).OrderByDescending(r => r.Priority).FirstOrDefault(); if (existingRuleForSameVmWithHighestPriority != null) { startingAt = existingRuleForSameVmWithHighestPriority.Priority += increaseBy; } return(await FindNextPriority(parameters, startingAt, increaseBy, highestAllowed, direction, cancellationToken)); }
public Task <ResourceProvisioningResult> EnsureCreated(ResourceProvisioningParameters parameters, CancellationToken cancellationToken = default) { if (_resourceType == AzureResourceType.ResourceGroup) { Log($"Creating resource group: {parameters.ResourceGroupName}"); } else { Log($"Creating resource {parameters.Name} in resource group {parameters.ResourceGroupName}"); } throw new System.NotImplementedException(); }
public Task <ResourceProvisioningResult> Delete(ResourceProvisioningParameters parameters) { if (_resourceType == AzureResourceType.ResourceGroup) { Log($"Deleting resource group: {parameters.ResourceGroupName}"); } else { Log($"Updating resource {parameters.Name} in resource group {parameters.ResourceGroupName}"); } throw new System.NotImplementedException(); }
public Task <ResourceProvisioningResult> GetSharedVariables(ResourceProvisioningParameters parameters) { if (_resourceType == AzureResourceType.ResourceGroup) { Log($"Returning shared variables for resource group: {parameters.ResourceGroupName}"); } else { Log($"Returning shared variables for resource {parameters.Name} in resource group {parameters.ResourceGroupName}"); } throw new System.NotImplementedException(); }
protected string GetSharedVariableThrowIfNotFoundOrEmpty(ResourceProvisioningParameters parameters, string variableName, string descriptionForErrorMessage) { if (!parameters.TryGetSharedVariable(variableName, out string sharedVariableValue)) { throw new ArgumentException($"{this.GetType().Name}: Missing {descriptionForErrorMessage} from input"); } else if (String.IsNullOrWhiteSpace(sharedVariableValue)) { throw new ArgumentException($"{this.GetType().Name}: Empty {descriptionForErrorMessage} from input"); } return(sharedVariableValue); }
public async Task <ResourceProvisioningResult> EnsureDeleted(ResourceProvisioningParameters parameters) { try { await Delete(parameters.ResourceGroupName, parameters.Name); var provisioningState = await GetProvisioningState(parameters.ResourceGroupName, parameters.Name); return(ResourceProvisioningResultUtil.CreateFromProvisioningState(provisioningState)); } catch (Exception) { throw; } }
public async Task <ResourceProvisioningResult> Update(ResourceProvisioningParameters parameters, CancellationToken cancellationToken = default) { _logger.LogInformation($"Updating VM {parameters.Name}"); var vm = await GetInternalAsync(parameters.ResourceGroupName, parameters.Name); var primaryNic = await _azure.NetworkInterfaces.GetByIdAsync(vm.PrimaryNetworkInterfaceId, cancellationToken); var vmSettings = CloudResourceConfigStringSerializer.VmSettings(parameters.ConfigurationString); await UpdateVmRules(parameters, vmSettings, primaryNic.PrimaryPrivateIP, cancellationToken); var result = CreateCRUDResult(vm); return(result); }
public async Task <ResourceProvisioningResult> Handle( CloudResourceOperationDto operation, ResourceProvisioningParameters currentCrudInput, IPerformResourceProvisioning provisioningService ) { try { var cancellation = new CancellationTokenSource(); var currentCrudResultTask = CreateProvisioningResultTask(operation, currentCrudInput, provisioningService, cancellation); while (!currentCrudResultTask.IsCompleted) { operation = await _cloudResourceOperationUpdateService.TouchAsync(operation.Id); if (await _cloudResourceReadService.ResourceIsDeleted(operation.Resource.Id) || operation.Status == CloudResourceOperationState.ABORTED || operation.Status == CloudResourceOperationState.ABANDONED) { _provisioningLogService.OperationWarning(operation, "Operation aborted, provisioning will be aborted"); cancellation.Cancel(); break; } Thread.Sleep((int)TimeSpan.FromSeconds(3).TotalMilliseconds); } var provisioningResult = currentCrudResultTask.Result; if (operation.OperationType == CloudResourceOperationType.CREATE) { _provisioningLogService.OperationInformation(operation, $"Storing resource Id and Name"); await _cloudResourceUpdateService.UpdateResourceIdAndName(operation.Resource.Id, provisioningResult.IdInTargetSystem, provisioningResult.NameInTargetSystem); } return(provisioningResult); } catch (Exception ex) { if (ex.InnerException != null && ex.InnerException.Message.Contains("A task was canceled")) { throw new ProvisioningException($"Resource provisioning (Create/update) aborted.", logAsWarning: true, innerException: ex.InnerException); } else { throw new ProvisioningException($"Resource provisioning (Create/update) failed.", CloudResourceOperationState.FAILED, postponeQueueItemFor: 10, innerException: ex); } } }
async Task <int> FindNextPriority(ResourceProvisioningParameters parameters, int startingAt, int increaseBy, int highestAllowed, string direction, CancellationToken cancellationToken = default) { var allExistingRulesInNsg = await _azureNetworkSecurityGroupRuleService.GetNsgRulesForDirection(parameters.ResourceGroupName, parameters.NetworkSecurityGroupName, direction, cancellationToken); var relevantExistingRulesInNsg = allExistingRulesInNsg.Where(r => r.Value.Priority >= startingAt && r.Value.Priority <= highestAllowed).OrderBy(r => r.Value.Priority); if (relevantExistingRulesInNsg.Count() == 0) { return(startingAt); } var curPriority = startingAt; while (curPriority <= highestAllowed) { bool collision = false; foreach (var curExisting in relevantExistingRulesInNsg) { if (curExisting.Value == null) { break; } if (curPriority > curExisting.Value.Priority) { continue; } else if ((curExisting.Value.Priority - curPriority) < 10) { collision = true; break; } } if (collision) { curPriority += increaseBy; } else { return(curPriority); } } throw new Exception($"Unable to determine next priority for vm {parameters.Name}. Stopped at {highestAllowed}"); }
public static void PrepareForNewOperation(ResourceProvisioningParameters currentCrudInput, CloudResourceOperationDto currentOperation, ResourceProvisioningResult lastResult, string nsgName = null) { currentCrudInput.ResetButKeepSharedVariables(lastResult?.NewSharedVariables); currentCrudInput.Name = currentOperation.Resource.ResourceName; currentCrudInput.StudyName = currentOperation.Resource.StudyName; currentCrudInput.DatabaseId = currentOperation.Resource.Id; currentCrudInput.StudyId = currentOperation.Resource.StudyId; currentCrudInput.SandboxId = currentOperation.Resource.SandboxId; currentCrudInput.DatasetId = currentOperation.Resource.DatasetId; currentCrudInput.SandboxName = currentOperation.Resource.SandboxName; currentCrudInput.ResourceGroupName = currentOperation.Resource.ResourceGroupName; currentCrudInput.Region = currentOperation.Resource.Region; currentCrudInput.Tags = currentOperation.Resource.Tags; currentCrudInput.ConfigurationString = currentOperation.Resource.ConfigString; currentCrudInput.NetworkSecurityGroupName = nsgName; }
public static ResourceProvisioningResult Create(ResourceProvisioningParameters provisionParameters, string resourceType) { var result = new ResourceProvisioningResult(); result.CurrentProvisioningState = CloudResourceProvisioningStates.SUCCEEDED; result.IdInTargetSystem = resourceType == AzureResourceType.ResourceGroup ? $"resourceGroups/{provisionParameters.ResourceGroupName}" : $"resources/{provisionParameters.Name}"; result.NameInTargetSystem = resourceType == AzureResourceType.ResourceGroup ? provisionParameters.ResourceGroupName : provisionParameters.Name; if (resourceType == AzureResourceType.NetworkSecurityGroup) { result.NewSharedVariables.Add(AzureCrudSharedVariable.NETWORK_SECURITY_GROUP_NAME, provisionParameters.Name); } else if (resourceType == AzureResourceType.VirtualNetwork) { result.NewSharedVariables.Add(AzureCrudSharedVariable.BASTION_SUBNET_ID, "bastionSubnetId"); } return(result); }
public async Task <ResourceProvisioningResult> EnsureCreated(ResourceProvisioningParameters parameters, CancellationToken cancellationToken = default) { _logger.LogInformation($"Ensuring Network Security Group exists for sandbox with Name: {parameters.SandboxName}! Resource Group: {parameters.ResourceGroupName}"); var nsg = await GetResourceInternalAsync(parameters.ResourceGroupName, parameters.Name, false); if (nsg == null) { _logger.LogInformation($"Network Security Group not found for sandbox with Name: {parameters.SandboxName}! Resource Group: {parameters.ResourceGroupName}. Creating!"); nsg = await CreateInternal(GetRegionFromString(parameters.Region), parameters.ResourceGroupName, parameters.Name, parameters.Tags, cancellationToken); } var result = CreateResult(nsg); _logger.LogInformation($"Done ensuring Network Security Group exists for sandbox with Id: {parameters.SandboxName}! Id: {nsg.Id}"); return(result); }
public async Task <ResourceProvisioningResult> EnsureCreated(ResourceProvisioningParameters parameters, CancellationToken cancellationToken = default) { _logger.LogInformation($"Creating Resource Group for sandbox with Name: {parameters.SandboxName}! Resource Group: {parameters.ResourceGroupName}"); var resourceGroup = await GetResourceGroupAsync(parameters.ResourceGroupName, false); if (resourceGroup == null) { _logger.LogInformation($"Resource group not found, creating"); resourceGroup = await CreateInternal(parameters.ResourceGroupName, GetRegionFromString(parameters.Region), parameters.Tags); } else { _logger.LogInformation($"Resource group allready exists"); } var crudResult = ResourceProvisioningResultUtil.CreateFromIResource(resourceGroup); crudResult.CurrentProvisioningState = resourceGroup.ProvisioningState.ToString(); _logger.LogInformation($"Done ensuring Resource Group for sandbox with Id: {parameters.SandboxName}! Resource Group Id: {resourceGroup.Id}"); return(crudResult); }
public async Task <ResourceProvisioningResult> EnsureCreated(ResourceProvisioningParameters parameters, CancellationToken cancellationToken = default) { _logger.LogInformation($"Ensuring Storage Account {parameters.Name} exists in Resource Group: {parameters.ResourceGroupName}"); var storageAccount = await GetResourceAsync(parameters.ResourceGroupName, parameters.Name, false); if (storageAccount == null) { _logger.LogInformation($"Storage account not found, creating"); var nameIsAvailable = await _azure.StorageAccounts.CheckNameAvailabilityAsync(parameters.Name); if (!(bool)nameIsAvailable.IsAvailable) { _logger.LogError($"StorageAccountName not available/invalid. Message: {nameIsAvailable.Message}"); throw new ArgumentException($"StorageAccountName not available/invalid. Message: {nameIsAvailable.Message}"); } // Create storage account storageAccount = await _azure.StorageAccounts.Define(parameters.Name) .WithRegion(parameters.Region) .WithExistingResourceGroup(parameters.ResourceGroupName) .WithAccessFromAllNetworks() .WithGeneralPurposeAccountKindV2() .WithOnlyHttpsTraffic() .WithSku(StorageAccountSkuType.Standard_LRS) .WithTags(parameters.Tags) .CreateAsync(cancellationToken); _logger.LogInformation($"Done creating storage account"); } var result = CreateResult(storageAccount); return(result); }
public Task <ResourceProvisioningResult> EnsureDeleted(ResourceProvisioningParameters parameters) { throw new NotImplementedException(); }
public async Task <ResourceProvisioningResult> EnsureCreated(ResourceProvisioningParameters parameters, CancellationToken cancellationToken = default) { _logger.LogInformation($"Ensuring VM exists: {parameters.Name} in resource Group: {parameters.ResourceGroupName}"); var vmSettings = CloudResourceConfigStringSerializer.VmSettings(parameters.ConfigurationString); var virtualMachine = await GetInternalAsync(parameters.ResourceGroupName, parameters.Name, false); if (virtualMachine == null) { _logger.LogInformation($"VM {parameters.Name} did not exist in resource Group: {parameters.ResourceGroupName}, creating!"); var passwordReference = vmSettings.Password; string password = await GetPasswordFromKeyVault(passwordReference); string vmSize = vmSettings.Size; virtualMachine = await CreateInternalAsync(GetRegionFromString(parameters.Region), parameters.ResourceGroupName, parameters.Name, vmSettings.NetworkName, vmSettings.SubnetName, vmSettings.Username, password, vmSize, vmSettings.OperatingSystem, vmSettings.OperatingSystemCategory, parameters.Tags, vmSettings.DiagnosticStorageAccountName, cancellationToken); await DeletePasswordFromKeyVault(passwordReference); if (vmSettings.DataDisks != null && vmSettings.DataDisks.Count > 0) { foreach (var curDisk in vmSettings.DataDisks) { var sizeAsInt = Convert.ToInt32(curDisk); if (sizeAsInt == 0) { throw new Exception($"Illegal data disk size: {curDisk}"); } await ApplyVmDataDisksInternalAsync(parameters.ResourceGroupName, parameters.Name, sizeAsInt, parameters.Tags); } } _logger.LogInformation($"Done creating Virtual Machine for sandbox with Id: {parameters.SandboxId}! Id: {virtualMachine.Id}"); } else { //Validate data disks if (vmSettings.DataDisks != null && vmSettings.DataDisks.Count > 0) { if (virtualMachine.DataDisks.Count != vmSettings.DataDisks.Count) { throw new Exception($"Data disk(s) not created properly. Expected count of {vmSettings.DataDisks}, saw {vmSettings.DataDisks.Count} on VM"); } } } var primaryNic = await _azure.NetworkInterfaces.GetByIdAsync(virtualMachine.PrimaryNetworkInterfaceId, cancellationToken); //Add tags to NIC await primaryNic.UpdateTags().WithTags(parameters.Tags).ApplyTagsAsync(); await UpdateVmRules(parameters, vmSettings, primaryNic.PrimaryPrivateIP, cancellationToken); var result = CreateCRUDResult(virtualMachine); return(result); }
public async Task HandleWork(ProvisioningQueueParentDto queueParentItem) { _provisioningLogService.HandlingQueueParent(queueParentItem); //One per child item in queue item CloudResourceOperationDto currentOperation = null; //Get's re-used amonong child elements because the operations might share variables var currentProvisioningParameters = new ResourceProvisioningParameters(); ResourceProvisioningResult currentProvisioningResult = null; try { //If more than one child/operation, run basic checks on all operations before starting if (queueParentItem.Children.Count > 1) { _provisioningLogService.QueueParentProgressInformation(queueParentItem, "Multiple child item, running pre checks"); foreach (var queueChildItem in queueParentItem.Children) { currentOperation = await _resourceOperationReadService.GetByIdAsync(queueChildItem.ResourceOperationId); _operationCheckService.ThrowIfPossiblyInProgress(currentOperation); } } foreach (var queueChildItem in queueParentItem.Children) { try { currentOperation = await _resourceOperationReadService.GetByIdAsync(queueChildItem.ResourceOperationId); _provisioningLogService.OperationInformation(currentOperation, "Starting operation"); _operationCheckService.ThrowIfTryCountExceededOrAborted(currentOperation); _operationCheckService.ThrowIfResourceIsDeletedAndOperationIsNotADelete(currentOperation); _operationCheckService.ThrowIfPossiblyInProgress(currentOperation); await _operationCheckService.ThrowIfDependentOnUnfinishedOperationAsync(currentOperation, queueParentItem); string networkSecurityGroupName = null; //Only relevant for Sandbox Resource Creation if (currentOperation.Resource.SandboxId.HasValue) { var nsg = CloudResourceUtil.GetSibilingResource(await _resourceReadService.GetByIdNoAccessCheckAsync(currentOperation.Resource.Id), AzureResourceType.NetworkSecurityGroup); networkSecurityGroupName = nsg?.ResourceName; } ProvisioningParamaterUtil.PrepareForNewOperation(currentProvisioningParameters, currentOperation, currentProvisioningResult, networkSecurityGroupName); await _provisioningQueueService.IncreaseInvisibleBasedOnResource(currentOperation, queueParentItem); _provisioningLogService.OperationInformation(currentOperation, "Initial checks passed"); if (_createAndUpdateService.CanHandle(currentOperation)) { _provisioningLogService.OperationInformation(currentOperation, "Operation is CREATE or UPDATE"); var provisioningService = AzureResourceServiceResolver.GetProvisioningServiceOrThrow(_serviceProvider, currentOperation.Resource.ResourceType); if (await _operationCompletedService.HandledAsAllreadyCompletedAsync(currentOperation)) { _provisioningLogService.OperationInformation(currentOperation, "Operation is allready completed"); currentProvisioningResult = await provisioningService.GetSharedVariables(currentProvisioningParameters); continue; } else { currentOperation = await _resourceOperationUpdateService.SetInProgressAsync(currentOperation.Id, _requestIdService.GetRequestId()); currentProvisioningResult = await _createAndUpdateService.Handle(currentOperation, currentProvisioningParameters, provisioningService); } currentOperation = await _resourceOperationUpdateService.TouchAsync(currentOperation.Id); await _resourceOperationUpdateService.UpdateStatusAsync(currentOperation.Id, CloudResourceOperationState.DONE_SUCCESSFUL, updatedProvisioningState : currentProvisioningResult.CurrentProvisioningState); } else if (_deleteOperationService.CanHandle(currentOperation)) { _provisioningLogService.OperationInformation(currentOperation, "Operation is DELETE"); var provisioningService = AzureResourceServiceResolver.GetProvisioningServiceOrThrow(_serviceProvider, currentOperation.Resource.ResourceType); currentOperation = await _resourceOperationUpdateService.SetInProgressAsync(currentOperation.Id, _requestIdService.GetRequestId()); currentProvisioningResult = await _deleteOperationService.Handle(currentOperation, currentProvisioningParameters, provisioningService); await _resourceOperationUpdateService.UpdateStatusAsync(currentOperation.Id, CloudResourceOperationState.DONE_SUCCESSFUL, updatedProvisioningState : null); } else if (_roleProvisioningService.CanHandle(currentOperation)) { _provisioningLogService.OperationInformation(currentOperation, "Operation is ENSURE ROLES"); currentOperation = await _resourceOperationUpdateService.SetInProgressAsync(currentOperation.Id, _requestIdService.GetRequestId()); await _roleProvisioningService.Handle(currentOperation); await _resourceOperationUpdateService.UpdateStatusAsync(currentOperation.Id, CloudResourceOperationState.DONE_SUCCESSFUL); } else if (_firewallService.CanHandle(currentOperation)) { _provisioningLogService.OperationInformation(currentOperation, "Operation is ENSURE FIREWALL"); var firewallRuleService = AzureResourceServiceResolver.GetFirewallRuleService(_serviceProvider, currentOperation.Resource.ResourceType); currentOperation = await _resourceOperationUpdateService.SetInProgressAsync(currentOperation.Id, _requestIdService.GetRequestId()); if (firewallRuleService is IHasFirewallRules) { await _firewallService.Handle(currentOperation, firewallRuleService ); await _resourceOperationUpdateService.UpdateStatusAsync(currentOperation.Id, CloudResourceOperationState.DONE_SUCCESSFUL); } else { throw new ProvisioningException($"Service {firewallRuleService.GetType().Name} does not support firewall operations", CloudResourceOperationState.ABORTED, deleteFromQueue: true); } } else if (_corsRuleProvisioningService.CanHandle(currentOperation)) { _provisioningLogService.OperationInformation(currentOperation, "Operation is ENSURE CORS RULES"); var corsRuleService = AzureResourceServiceResolver.GetCorsRuleServiceOrThrow(_serviceProvider, currentOperation.Resource.ResourceType); currentOperation = await _resourceOperationUpdateService.SetInProgressAsync(currentOperation.Id, _requestIdService.GetRequestId()); if (corsRuleService is IHasCorsRules) { await _corsRuleProvisioningService.Handle(currentOperation, corsRuleService); await _resourceOperationUpdateService.UpdateStatusAsync(currentOperation.Id, CloudResourceOperationState.DONE_SUCCESSFUL); } else { throw new ProvisioningException($"Service {corsRuleService.GetType().Name} does not support CORS operations", CloudResourceOperationState.ABORTED, deleteFromQueue: true); } } else { throw new ProvisioningException("Unknown operation type", CloudResourceOperationState.ABORTED); } _provisioningLogService.OperationInformation(currentOperation, "Successfully handeled operation"); } catch (ProvisioningException ex) //Inner loop, ordinary exception is not catched { if (ex.LogAsWarning) { if (ex.IncludeExceptionInWarningLog) { _provisioningLogService.OperationWarning(currentOperation, "Operation aborted", ex); } else { _provisioningLogService.OperationWarning(currentOperation, $"Operation aborted: {ex.Message}"); } } else { _provisioningLogService.OperationError(ex, currentOperation, "Operation failed"); } currentOperation = await _resourceOperationUpdateService.SetErrorMessageAsync(currentOperation.Id, ex); if (!String.IsNullOrWhiteSpace(ex.NewOperationStatus)) { currentOperation = await _resourceOperationUpdateService.UpdateStatusAsync(currentOperation.Id, ex.NewOperationStatus); } if (!ex.ProceedWithOtherOperations) { throw; } } } //foreach _provisioningLogService.QueueParentProgressInformation(queueParentItem, "Done"); await _provisioningQueueService.DeleteMessageAsync(queueParentItem); await MoveUpAnyDependentOperations(queueParentItem); } catch (ProvisioningException ex) //Outer loop catch 1 { if (ex.DeleteFromQueue) { _provisioningLogService.QueueParentProgressWarning(queueParentItem, "Deleting due to exception"); await _provisioningQueueService.DeleteMessageAsync(queueParentItem); } else if (ex.PostponeQueueItemFor.HasValue && ex.PostponeQueueItemFor.Value > 0) { if (currentOperation.TryCount < currentOperation.MaxTryCount) { if (queueParentItem.DequeueCount == 5) { _provisioningLogService.QueueParentProgressWarning(queueParentItem, "Re-queuing after exception"); await _provisioningQueueService.ReQueueMessageAsync(queueParentItem, ex.PostponeQueueItemFor.Value); } else { _provisioningLogService.QueueParentProgressWarning(queueParentItem, "Increasing invisibility after exception"); await _provisioningQueueService.IncreaseInvisibilityAsync(queueParentItem, ex.PostponeQueueItemFor.Value); } } } if (ex.StoreQueueInfoOnOperation) { if (!queueParentItem.NextVisibleOn.HasValue) { _provisioningLogService.QueueParentProgressError(queueParentItem, "Could not store queue info on operation, no next visible time exist"); } else { currentOperation = await _resourceOperationUpdateService.SetQueueInformationAsync(currentOperation.Id, queueParentItem.MessageId, queueParentItem.PopReceipt, queueParentItem.NextVisibleOn.Value); } } } catch (Exception ex) //Outer loop catch 2 { _provisioningLogService.QueueParentProgressError(queueParentItem, "Unhandled exception occured"); await _provisioningQueueService.DeleteMessageAsync(queueParentItem); } }
public Task <ResourceProvisioningResult> Update(ResourceProvisioningParameters parameters, CancellationToken cancellationToken = default) { throw new NotImplementedException(); }
Task <ResourceProvisioningResult> CreateProvisioningResultTask(CloudResourceOperationDto operation, ResourceProvisioningParameters currentCrudInput, IPerformResourceProvisioning provisioningService, CancellationTokenSource cancellation) { if (operation.OperationType == CloudResourceOperationType.CREATE) { return(provisioningService.EnsureCreated(currentCrudInput, cancellation.Token)); } return(provisioningService.Update(currentCrudInput, cancellation.Token)); }
async Task UpdateVmRules(ResourceProvisioningParameters parameters, VmSettingsDto vmSettings, string privateIp, CancellationToken cancellationToken = default) { _logger.LogInformation($"Setting desired VM rules for {parameters.Name}"); var existingRules = await _azureNetworkSecurityGroupRuleService.GetNsgRulesContainingName(parameters.ResourceGroupName, parameters.NetworkSecurityGroupName, $"{AzureResourceNameUtil.NSG_RULE_FOR_VM_PREFIX}{parameters.DatabaseId}", cancellationToken); var existingRulesThatStillExists = new HashSet <string>(); if (vmSettings.Rules == null) { throw new Exception($"No rules exists for VM {parameters.Name}"); } else { foreach (var curRule in vmSettings.Rules) { try { var ruleMapped = _mapper.Map <NsgRuleDto>(curRule); if (curRule.Direction == RuleDirection.Inbound) { ruleMapped.SourceAddress = curRule.Ip; ruleMapped.SourcePort = curRule.Port; ruleMapped.DestinationAddress = privateIp; ruleMapped.DestinationPort = curRule.Port; //get existing rule and use that name if (existingRules.TryGetValue(curRule.Name, out NsgRuleDto existingRule)) { existingRulesThatStillExists.Add(curRule.Name); ruleMapped.Priority = existingRule.Priority; await _azureNetworkSecurityGroupRuleService.UpdateInboundRule(parameters.ResourceGroupName, parameters.NetworkSecurityGroupName, ruleMapped, cancellationToken); } else { ruleMapped.Priority = await FindNextPriority(parameters, existingRules, AzureVmConstants.MIN_RULE_PRIORITY, 10, AzureVmConstants.MAX_RULE_PRIORITY, curRule.Direction.ToString()); await _azureNetworkSecurityGroupRuleService.AddInboundRule(parameters.ResourceGroupName, parameters.NetworkSecurityGroupName, ruleMapped, cancellationToken); } } else { ruleMapped.SourceAddress = privateIp; ruleMapped.SourcePort = curRule.Port; if (ruleMapped.Name.Contains(AzureVmConstants.RulePresets.OPEN_CLOSE_INTERNET)) { ruleMapped.DestinationAddress = "*"; ruleMapped.DestinationPort = 0; } else { ruleMapped.DestinationAddress = curRule.Ip; ruleMapped.DestinationPort = curRule.Port; } if (existingRules.TryGetValue(curRule.Name, out NsgRuleDto existingRule)) { existingRulesThatStillExists.Add(curRule.Name); ruleMapped.Priority = existingRule.Priority; //Ensure same priority is re-used await _azureNetworkSecurityGroupRuleService.UpdateOutboundRule(parameters.ResourceGroupName, parameters.NetworkSecurityGroupName, ruleMapped, cancellationToken); } else { ruleMapped.Priority = await FindNextPriority(parameters, existingRules, AzureVmConstants.MIN_RULE_PRIORITY, 10, AzureVmConstants.MAX_RULE_PRIORITY, curRule.Direction.ToString()); await _azureNetworkSecurityGroupRuleService.AddOutboundRule(parameters.ResourceGroupName, parameters.NetworkSecurityGroupName, ruleMapped, cancellationToken); } } } catch (Exception ex) { throw new Exception($"Unable to create rule {curRule.Name} for VM {parameters.Name}", ex); } } } if (existingRules != null && existingRules.Count > 0) { foreach (var curExistingKvp in existingRules) { if (!existingRulesThatStillExists.Contains(curExistingKvp.Key)) { await _azureNetworkSecurityGroupRuleService.DeleteRule(parameters.ResourceGroupName, parameters.NetworkSecurityGroupName, curExistingKvp.Key, cancellationToken); } } } _logger.LogInformation($"Done setting desired VM rules for {parameters.Name}"); }