public static string GetDeadlineExcludeFromLimitGroupsString(this PoolConfigurationModel poolConfiguration, DeadlineConfig deadlineConfig) { if (poolConfiguration == null) { return(null); } // Get pool limit groups, or environment limitgroups, if specified. var limitgroups = !string.IsNullOrWhiteSpace(poolConfiguration.ExcludeFromLimitGroups) ? poolConfiguration.ExcludeFromLimitGroups : deadlineConfig != null && !string.IsNullOrWhiteSpace(deadlineConfig.ExcludeFromLimitGroups) ? deadlineConfig.ExcludeFromLimitGroups : null; if (!string.IsNullOrWhiteSpace(limitgroups)) { var trimmed = limitgroups .Split(',', StringSplitOptions.RemoveEmptyEntries) .Select(lg => lg.Trim()); if (trimmed.Any()) { // Multiple limit groups are separated by a space return(string.Join(';', trimmed)); } } return(null); }
public async Task <ActionResult <PoolConfigurationModel> > New(string envId) { var environment = await _environmentCoordinator.GetEnvironment(envId); if (environment == null) { return(RedirectToAction("Index", "Environments")); } var result = new PoolConfigurationModel { EnvironmentName = envId }; try { await PopulateSelectableProperties(environment, result); } catch (CloudException cEx) { // TODO: Log somewhere Console.WriteLine(cEx); ModelState.AddModelError("", $"Failed to configure pool creation form with error: {cEx.Message}"); } return(View(result)); }
private void ValidateImageRefOrCustomAndSku(PoolConfigurationModel poolConfiguration) { if (string.IsNullOrWhiteSpace(poolConfiguration.ImageReference) && string.IsNullOrWhiteSpace(poolConfiguration.CustomImageReference)) { ModelState.AddModelError(nameof(PoolConfigurationModel.ImageReference), Validation.Errors.Custom.ImageRefOrCustom); ModelState.AddModelError(nameof(PoolConfigurationModel.CustomImageReference), Validation.Errors.Custom.ImageRefOrCustom); } }
public void CanUseGroupsInsteadOfPoolsAndSpecifyAdditionalGroups() { var poolConfig = new PoolConfigurationModel { PoolName = "mypool", UseDeadlineGroups = true, AdditionalGroups = "group1,group2" }; Assert.Equal("mypool,group1,group2", poolConfig.GetDeadlineGroupsString()); }
public void CanSpecifyAdditionalGroups() { var poolConfig = new PoolConfigurationModel { PoolName = "mypool", AdditionalGroups = "group1,group2" }; Assert.Equal("group1,group2", poolConfig.GetDeadlineGroupsString()); }
public void LimitGroupsAreTrimmed() { var poolConfig = new PoolConfigurationModel { ExcludeFromLimitGroups = "limitgroup, limitgroup2" }; var deadlineConfig = new DeadlineConfig(); Assert.Equal("limitgroup;limitgroup2", poolConfig.GetDeadlineExcludeFromLimitGroupsString(deadlineConfig)); }
public void DefaultsToPoolName() { var poolConfig = new PoolConfigurationModel { PoolName = "mypool" }; Assert.Equal("mypool", poolConfig.GetDeadlinePoolsString()); Assert.Null(poolConfig.GetDeadlineGroupsString()); }
public void UseGroupInsteadOfPool() { var poolConfig = new PoolConfigurationModel { PoolName = "mypool", UseDeadlineGroups = true, }; Assert.Equal("mypool", poolConfig.GetDeadlineGroupsString()); Assert.Null(poolConfig.GetDeadlinePoolsString()); }
public void CanSpecifyAdditionalPools() { var poolConfig = new PoolConfigurationModel { PoolName = "mypool", AdditionalPools = "pool1,pool2" }; Assert.Equal("mypool,pool1,pool2", poolConfig.GetDeadlinePoolsString()); Assert.Null(poolConfig.GetDeadlineGroupsString()); }
public void EmptyExcludeFromLimitGroupsReturnsNull() { var poolConfig = new PoolConfigurationModel { ExcludeFromLimitGroups = "" }; var deadlineConfig = new DeadlineConfig(); Assert.Null(poolConfig.GetDeadlineExcludeFromLimitGroupsString(deadlineConfig)); }
public void EnvironmentLimitGroupsIsUsedWhenNoPoolLimitGroup() { var poolConfig = new PoolConfigurationModel { ExcludeFromLimitGroups = null }; var envDeadlineConfig = new DeadlineConfig { ExcludeFromLimitGroups = "environmentLimitGroup" }; Assert.Equal("environmentLimitGroup", poolConfig.GetDeadlineExcludeFromLimitGroupsString(envDeadlineConfig)); }
public void PoolLimitGroupsOverrideEnvironment() { var poolConfig = new PoolConfigurationModel { ExcludeFromLimitGroups = "limitgroup" }; var envDeadlineConfig = new DeadlineConfig { ExcludeFromLimitGroups = "environmentLimitGroup" }; Assert.Equal("limitgroup", poolConfig.GetDeadlineExcludeFromLimitGroupsString(envDeadlineConfig)); }
private void AppendOpenCueParamsToStartTask( PoolConfigurationModel poolConfiguration, RenderingEnvironment environment, StartTask startTask, OpenCueConfig openCueConfig, InstallationPackage openCuePackage, bool isWindows) { var commandLine = startTask.CommandLine; var resourceFiles = new List <ResourceFile>(startTask.ResourceFiles); if (environment.KeyVaultServicePrincipal != null) { commandLine += GetParameterSet(isWindows, "tenantId", environment.KeyVaultServicePrincipal.TenantId.ToString()); commandLine += GetParameterSet(isWindows, "applicationId", environment.KeyVaultServicePrincipal.ApplicationId.ToString()); commandLine += GetParameterSet(isWindows, "keyVaultCertificateThumbprint", environment.KeyVaultServicePrincipal.Thumbprint); commandLine += GetParameterSet(isWindows, "keyVaultName", environment.KeyVault.Name); } if (!string.IsNullOrWhiteSpace(openCueConfig.CuebotHostnameOrIp)) { commandLine += GetParameterSet(isWindows, "cuebotHost", openCueConfig.CuebotHostnameOrIp); } if (!string.IsNullOrWhiteSpace(openCueConfig.Facility)) { commandLine += GetParameterSet(isWindows, "facility", openCueConfig.Facility); } var groups = $"azure,{poolConfiguration.PoolName}"; if (poolConfiguration.AdditionalGroups != null && poolConfiguration.AdditionalGroups.Any()) { groups += $",{string.Join(',', poolConfiguration.AdditionalGroups)}"; } if (!string.IsNullOrWhiteSpace(groups)) { commandLine += GetParameterSet(isWindows, "groups", groups); } if (openCuePackage != null && !string.IsNullOrEmpty(openCuePackage.Container)) { resourceFiles.Add(GetContainerResourceFile(openCuePackage.Container, openCuePackage.PackageName)); commandLine += GetParameterSet(isWindows, "installerPath", openCuePackage.PackageName); } commandLine += ";"; startTask.CommandLine = commandLine; startTask.ResourceFiles = resourceFiles; }
public static string GetDeadlinePoolsString(this PoolConfigurationModel poolConfiguration) { if (poolConfiguration == null) { return(null); } var pools = poolConfiguration.UseDeadlineGroups ? "" : poolConfiguration.PoolName; if (poolConfiguration.AdditionalPools != null && poolConfiguration.AdditionalPools.Any()) { pools += string.IsNullOrEmpty(pools) ? "" : ","; pools += string.Join(',', poolConfiguration.AdditionalPools); } return(string.IsNullOrEmpty(pools) ? null : pools); }
public static string GetDeadlineGroupsString(this PoolConfigurationModel poolConfiguration) { if (poolConfiguration == null) { return(null); } var groups = poolConfiguration.UseDeadlineGroups ? poolConfiguration.PoolName : ""; if (poolConfiguration.AdditionalGroups != null && poolConfiguration.AdditionalGroups.Any()) { groups += string.IsNullOrEmpty(groups) ? "" : ","; groups += string.Join(',', poolConfiguration.AdditionalGroups); } return(string.IsNullOrEmpty(groups) ? null : groups); }
private async Task AppendQubeParamsToStartTask( PoolConfigurationModel poolConfiguration, RenderingEnvironment environment, StartTask startTask, QubeConfig qubeConfig, InstallationPackage qubePackage, bool isWindows) { var commandLine = startTask.CommandLine; var resourceFiles = new List <ResourceFile>(startTask.ResourceFiles); var workerGroups = $"azure,{poolConfiguration.PoolName}"; if (poolConfiguration.AdditionalGroups != null && poolConfiguration.AdditionalGroups.Any()) { workerGroups += $",{string.Join(',', poolConfiguration.AdditionalGroups)}"; } commandLine += $"-qubeSupervisorIp {qubeConfig.SupervisorIp} " + $"-workerHostGroups '{workerGroups}'"; if (qubePackage != null && !string.IsNullOrEmpty(qubePackage.Container)) { resourceFiles.AddRange(await GetResourceFilesFromContainer(qubePackage.Container)); // Add qb.conf if one isn't already specified by the package if (!resourceFiles.Any(rf => rf.FilePath.Contains("qb.conf"))) { var qbConfResourceFile = new ResourceFile(httpUrl: _configuration["Qube:QbConf"], filePath: "qb.conf"); resourceFiles.Add(qbConfResourceFile); } } else { // No package, lets just configure commandLine += " -skipInstall "; } commandLine += ";"; startTask.CommandLine = commandLine; startTask.ResourceFiles = resourceFiles; }
private void AppendBYOSParamsToStartTask( PoolConfigurationModel poolConfiguration, RenderingEnvironment environment, StartTask startTask, BYOSConfig byosConfig, bool isWindows) { var commandLine = startTask.CommandLine; var resourceFiles = new List <ResourceFile>(startTask.ResourceFiles); if (environment.KeyVaultServicePrincipal != null) { commandLine += GetParameterSet(isWindows, "tenantId", environment.KeyVaultServicePrincipal.TenantId.ToString()); commandLine += GetParameterSet(isWindows, "applicationId", environment.KeyVaultServicePrincipal.ApplicationId.ToString()); commandLine += GetParameterSet(isWindows, "keyVaultCertificateThumbprint", environment.KeyVaultServicePrincipal.Thumbprint); commandLine += GetParameterSet(isWindows, "keyVaultName", environment.KeyVault.Name); } if (!string.IsNullOrWhiteSpace(byosConfig.SchedulerHostnameOrIp)) { commandLine += GetParameterSet(isWindows, "host", byosConfig.SchedulerHostnameOrIp); } var groups = $"azure,{poolConfiguration.PoolName}"; if (poolConfiguration.AdditionalGroups != null && poolConfiguration.AdditionalGroups.Any()) { groups += $",{string.Join(',', poolConfiguration.AdditionalGroups)}"; } if (!string.IsNullOrWhiteSpace(groups)) { commandLine += GetParameterSet(isWindows, "groups", groups); } commandLine += ";"; startTask.CommandLine = commandLine; startTask.ResourceFiles = resourceFiles; }
public static void AddDeadlinePoolsAndGroups(this IList <MetadataItem> metadata, PoolConfigurationModel poolConfiguration) { if (metadata == null) { return; } var pools = poolConfiguration.GetDeadlinePoolsString(); if (!string.IsNullOrEmpty(pools)) { metadata.AddOrUpdateMetadata(MetadataKeys.DeadlinePools, pools); } var groups = poolConfiguration.GetDeadlineGroupsString(); if (!string.IsNullOrEmpty(groups)) { metadata.AddOrUpdateMetadata(MetadataKeys.DeadlineGroups, groups); } }
private void AppendDeadlineParamsToStartTask( PoolConfigurationModel poolConfiguration, RenderingEnvironment environment, StartTask startTask, DeadlineConfig deadlineConfig, InstallationPackage deadlinePackage, bool isWindows) { var commandLine = startTask.CommandLine; var resourceFiles = new List <ResourceFile>(startTask.ResourceFiles); if (deadlinePackage != null && !string.IsNullOrEmpty(deadlinePackage.Container)) { resourceFiles.Add(GetContainerResourceFile(deadlinePackage.Container, deadlinePackage.PackageName)); commandLine += GetParameterSet(isWindows, "installerPath", deadlinePackage.PackageName); } if (isWindows & environment.Domain != null && environment.Domain.JoinDomain) { commandLine += GetParameterSet(isWindows, "domainJoin"); commandLine += GetParameterSet(isWindows, "domainName", environment.Domain.DomainName); commandLine += GetParameterSet(isWindows, "domainJoinUserName", environment.Domain.DomainJoinUsername); if (!string.IsNullOrWhiteSpace(environment.Domain.DomainWorkerOuPath)) { commandLine += GetParameterSet(isWindows, "domainOuPath", environment.Domain.DomainWorkerOuPath); } } if (environment.KeyVaultServicePrincipal != null) { commandLine += GetParameterSet(isWindows, "tenantId", environment.KeyVaultServicePrincipal.TenantId.ToString()); commandLine += GetParameterSet(isWindows, "applicationId", environment.KeyVaultServicePrincipal.ApplicationId.ToString()); commandLine += GetParameterSet(isWindows, "keyVaultCertificateThumbprint", environment.KeyVaultServicePrincipal.Thumbprint); commandLine += GetParameterSet(isWindows, "keyVaultName", environment.KeyVault.Name); } var repoPath = isWindows ? deadlineConfig.WindowsRepositoryPath : deadlineConfig.LinuxRepositoryPath; if (!string.IsNullOrWhiteSpace(repoPath)) { commandLine += GetParameterSet(isWindows, "deadlineRepositoryPath", deadlineConfig.WindowsRepositoryPath); } if (!string.IsNullOrEmpty(deadlineConfig.RepositoryUser)) { commandLine += GetParameterSet(isWindows, "deadlineRepositoryUserName", deadlineConfig.RepositoryUser); } if (!string.IsNullOrEmpty(deadlineConfig.ServiceUser)) { commandLine += GetParameterSet(isWindows, "deadlineServiceUserName", deadlineConfig.ServiceUser); } else { // If the Deadline slave is running under the start task context (not a service) // then we don't want to wait for success as it will block after launching the // Deadline launcher to prevent it being killed. startTask.WaitForSuccess = false; } if (deadlineConfig.LicenseMode != null) { commandLine += GetParameterSet(isWindows, "deadlineLicenseMode", deadlineConfig.LicenseMode.ToString()); } if (!string.IsNullOrEmpty(deadlineConfig.DeadlineRegion)) { commandLine += GetParameterSet(isWindows, "deadlineRegion", deadlineConfig.DeadlineRegion); } if (!string.IsNullOrEmpty(deadlineConfig.LicenseServer)) { commandLine += GetParameterSet(isWindows, "deadlineLicenseServer", deadlineConfig.LicenseServer); } var pools = poolConfiguration.GetDeadlinePoolsString(); if (!string.IsNullOrEmpty(pools)) { commandLine += GetParameterSet(isWindows, "deadlinePools", pools); } var groups = poolConfiguration.GetDeadlineGroupsString(); if (!string.IsNullOrEmpty(groups)) { commandLine += GetParameterSet(isWindows, "deadlineGroups", groups); } var limitGroups = poolConfiguration.GetDeadlineExcludeFromLimitGroupsString(deadlineConfig); if (!string.IsNullOrWhiteSpace(limitGroups)) { commandLine += GetParameterSet(isWindows, "excludeFromLimitGroups", limitGroups); } commandLine += "; "; if (!isWindows) { commandLine += "wait"; } startTask.CommandLine = commandLine; startTask.ResourceFiles = resourceFiles; }
public async Task <ActionResult <PoolConfigurationModel> > New(string envId, PoolConfigurationModel model) { ValidateImageRefOrCustomAndSku(model); var environment = await _environmentCoordinator.GetEnvironment(envId); if (environment == null) { return(RedirectToAction("Index", "Environments")); } var packageErrors = false; InstallationPackage renderManagerPackage = null; var renderManagerPackageSelected = model.SelectedRenderManagerPackageId != NoPackageSelected; if (renderManagerPackageSelected) { renderManagerPackage = await _packageCoordinator.GetPackage(model.SelectedRenderManagerPackageId); if (renderManagerPackage == null) { packageErrors = true; ModelState.AddModelError(nameof(PoolConfigurationModel.SelectedRenderManagerPackageId), Validation.Errors.Custom.PackageNotFound); } } InstallationPackage gpuPackage = null; var gpuPackageSelected = model.SelectedGpuPackageId != NoPackageSelected; if (gpuPackageSelected) { gpuPackage = await _packageCoordinator.GetPackage(model.SelectedGpuPackageId); if (gpuPackage == null) { packageErrors = true; ModelState.AddModelError(nameof(PoolConfigurationModel.SelectedGpuPackageId), Validation.Errors.Custom.PackageNotFound); } } List <InstallationPackage> generalPackages = new List <InstallationPackage>(); if (model.SelectedGeneralPackageIds != null) { foreach (var selectedGeneralPackageId in GetSelectedGeneralPackages(model.SelectedGeneralPackageIds)) { var package = await _packageCoordinator.GetPackage(selectedGeneralPackageId); if (package == null) { packageErrors = true; ModelState.AddModelError(nameof(PoolConfigurationModel.SelectedGeneralPackageIds), Validation.Errors.Custom.PackageNotFound); } else { generalPackages.Add(package); } } } if (!ModelState.IsValid || packageErrors) { ModelState.AddModelError("", Validation.Errors.Custom.FormSummary); await PopulateSelectableProperties(environment, model); return(View(model)); } try { var mappedPool = await MapFromConfiguration(model, renderManagerPackage, gpuPackage, generalPackages); await _poolCoordinator.CreatePool(environment, mappedPool); } catch (CloudException cEx) { // TODO: Log somewhere Console.WriteLine(cEx); ModelState.AddModelError("", $"Pool creation failed with error: {cEx.Message}{cEx.Response?.Content}"); } catch (Exception ex) { // TODO: Log somewhere Console.WriteLine(ex); ModelState.AddModelError("", $"Failed to configure pool with error: {ex}"); } // if any of the above failed if (!ModelState.IsValid) { await PopulateSelectableProperties(environment, model); return(View(model)); } return(RedirectToAction("Overview", new { envId, poolId = model.PoolName })); }
public async Task <StartTask> GetStartTask( PoolConfigurationModel poolConfiguration, RenderingEnvironment environment, InstallationPackage renderManagerPackage, InstallationPackage gpuPackage, IEnumerable <InstallationPackage> generalPackages, bool isWindows) { var resourceFiles = new List <ResourceFile>(); var startTask = new StartTask( "", resourceFiles, GetEnvironmentSettings(environment, isWindows), new UserIdentity( autoUser: new AutoUserSpecification(AutoUserScope.Pool, ElevationLevel.Admin)), 3, // retries true); // waitForSuccess AppendGpu(startTask, gpuPackage); AppendDomainSetup(startTask, environment); AppendGeneralPackages(startTask, generalPackages); // Appends the start task script, i.e. deadline-starttask.ps1 or tractor-starttask.ps1 AppendRenderManagerStartTask(environment, startTask, isWindows); // Appends the render manager specific parameters and package (if specified) switch (environment.RenderManager) { case RenderManagerType.Deadline: AppendDeadlineParamsToStartTask( poolConfiguration, environment, startTask, environment.RenderManagerConfig.Deadline, renderManagerPackage, isWindows); break; case RenderManagerType.OpenCue: AppendOpenCueParamsToStartTask( poolConfiguration, environment, startTask, environment.RenderManagerConfig.OpenCue, renderManagerPackage, isWindows); break; case RenderManagerType.Qube610: case RenderManagerType.Qube70: await AppendQubeParamsToStartTask( poolConfiguration, environment, startTask, environment.RenderManagerConfig.Qube, renderManagerPackage, isWindows); break; case RenderManagerType.Tractor2: AppendTractorParamsToStartTask( poolConfiguration, environment, startTask, environment.RenderManagerConfig.Tractor, renderManagerPackage, isWindows); break; case RenderManagerType.BYOS: AppendBYOSParamsToStartTask( poolConfiguration, environment, startTask, environment.RenderManagerConfig.BYOS, isWindows); break; } // Wrap all the start task command if (isWindows) { startTask.CommandLine = $"powershell.exe -ExecutionPolicy RemoteSigned -NoProfile \"$ErrorActionPreference='Stop'; {startTask.CommandLine}\""; } else { startTask.CommandLine = $"/bin/bash -c 'set -e; set -o pipefail; {startTask.CommandLine}'"; } return(startTask); }