public async Task <Study> UpdateMetadataAsync(int studyId, StudyUpdateDto updatedStudy, IFormFile logo = null)
{
if (studyId <= 0)
{
throw new ArgumentException("Study Id was zero or negative:" + studyId);
}
GenericNameValidation.ValidateName(updatedStudy.Name);
var studyFromDb = await GetStudyForUpdateAsync(studyId, UserOperation.Study_Update_Metadata);
if (updatedStudy.Name != studyFromDb.Name)
{
studyFromDb.Name = updatedStudy.Name;
}
if (updatedStudy.Description != studyFromDb.Description)
{
studyFromDb.Description = updatedStudy.Description;
}
if (updatedStudy.Vendor != studyFromDb.Vendor)
{
studyFromDb.Vendor = updatedStudy.Vendor;
}
if (updatedStudy.Restricted != studyFromDb.Restricted)
{
studyFromDb.Restricted = updatedStudy.Restricted;
}
if (updatedStudy.WbsCode != studyFromDb.WbsCode)
{
studyFromDb.WbsCode = updatedStudy.WbsCode;
await _studyWbsValidationService.ValidateForStudyCreateOrUpdate(studyFromDb);
}
if (updatedStudy.DeleteLogo)
{
if (!String.IsNullOrWhiteSpace(studyFromDb.LogoUrl))
{
studyFromDb.LogoUrl = "";
await _studyLogoDeleteService.DeleteAsync(_mapper.Map <Study>(updatedStudy));
}
}
else if (logo != null)
{
studyFromDb.LogoUrl = await _studyLogoCreateService.CreateAsync(studyFromDb.Id, logo);
}
studyFromDb.Updated = DateTime.UtcNow;
Validate(studyFromDb);
await _db.SaveChangesAsync();
return(studyFromDb);
}
public async Task <Sandbox> CreateAsync(int studyId, SandboxCreateDto sandboxCreateDto)
{
_logger.LogInformation(_sandboxCreateEventId, "Sandbox {0}: Starting", studyId);
Sandbox createdSandbox;
GenericNameValidation.ValidateName(sandboxCreateDto.Name);
if (String.IsNullOrWhiteSpace(sandboxCreateDto.Region))
{
throw new ArgumentException("Region not specified.");
}
// Verify that study with that id exists
var study = await _studyModelService.GetForSandboxCreateAndDeleteAsync(studyId, UserOperation.Study_Crud_Sandbox);
await _studyWbsValidationService.ValidateForSandboxCreationOrThrow(study);
//Check uniqueness of name
if (await _sandboxModelService.NameIsTaken(studyId, sandboxCreateDto.Name))
{
throw new ArgumentException($"A Sandbox called {sandboxCreateDto.Name} allready exists for Study");
}
try
{
createdSandbox = await _sandboxModelService.AddAsync(study, _mapper.Map <Sandbox>(sandboxCreateDto));
try
{
await _sandboxResourceCreateService.CreateBasicSandboxResourcesAsync(createdSandbox);
}
catch (Exception)
{
//Deleting sandbox entry and all related from DB
if (createdSandbox.Id > 0)
{
await _sandboxResourceDeleteService.UndoResourceCreationAsync(createdSandbox.Id);
await _sandboxModelService.HardDeleteAsync(createdSandbox.Id);
}
throw;
}
return(createdSandbox);
}
catch (Exception ex)
{
throw new Exception($"Sandbox creation failed: {ex.Message}", ex);
}
}
public void GenericNameValidationTest_ShouldNotReturn(string name)
{
GenericNameValidation.ValidateName(name);
}
public void GenericNameValidationTest_ShouldThrow(string name)
{
Assert.Throws <ArgumentException>(() => GenericNameValidation.ValidateName(name));
}
public async Task <VmDto> CreateAsync(int sandboxId, VirtualMachineCreateDto userInput)
{
CloudResource vmResourceEntry = null;
try
{
ValidateVmPasswordOrThrow(userInput.Password);
GenericNameValidation.ValidateName(userInput.Name);
_logger.LogInformation($"Creating Virtual Machine for sandbox: {sandboxId}");
var sandbox = await _sandboxModelService.GetByIdForResourceCreationAsync(sandboxId, UserOperation.Study_Crud_Sandbox);
var virtualMachineName = AzureResourceNameUtil.VirtualMachine(sandbox.Study.Name, sandbox.Name, userInput.Name);
await _cloudResourceCreateService.ValidateThatNameDoesNotExistThrowIfInvalid(virtualMachineName);
var tags = ResourceTagFactory.SandboxResourceTags(_config, sandbox.Study, sandbox);
var region = RegionStringConverter.Convert(sandbox.Region);
userInput.DataDisks = await TranslateDiskSizes(sandbox.Region, userInput.DataDisks);
var resourceGroup = await CloudResourceQueries.GetResourceGroupEntry(_db, sandboxId);
//Make this dependent on bastion create operation to be completed, since bastion finishes last
var dependsOn = await CloudResourceQueries.GetCreateOperationIdForBastion(_db, sandboxId);
vmResourceEntry = await _cloudResourceCreateService.CreateVmEntryAsync(sandboxId, resourceGroup, region.Name, tags, virtualMachineName, dependsOn, null);
//Create vm settings and immeately attach to resource entry
var vmSettingsString = await CreateVmSettingsString(sandbox.Region, vmResourceEntry.Id, sandbox.Study.Id, sandboxId, userInput);
vmResourceEntry.ConfigString = vmSettingsString;
await _cloudResourceUpdateService.Update(vmResourceEntry.Id, vmResourceEntry);
var queueParentItem = new ProvisioningQueueParentDto
{
Description = $"Create VM for Sandbox: {sandboxId}"
};
queueParentItem.Children.Add(new ProvisioningQueueChildDto()
{
ResourceOperationId = vmResourceEntry.Operations.FirstOrDefault().Id
});
await _provisioningQueueService.SendMessageAsync(queueParentItem);
var dtoMappedFromResource = _mapper.Map <VmDto>(vmResourceEntry);
return(dtoMappedFromResource);
}
catch (Exception ex)
{
try
{
//Delete resource if created
if (vmResourceEntry != null)
{
await _cloudResourceDeleteService.HardDeleteAsync(vmResourceEntry.Id);
}
}
catch (Exception rollbackEx)
{
_logger.LogError(rollbackEx, $"Failed to roll back VM creation for sandbox {sandboxId}");
}
throw new Exception($"Failed to create VM: {ex.Message}", ex);
}
}
