public void AddAutoDeployReleaseOverride(EnvironmentResource environment, TenantResource tenant, ReleaseResource release)
{
var autoDeployReleaseOverrideResource = new AutoDeployReleaseOverrideResource(environment.Id, tenant?.Id, release.Id);
var existingAutoDeployReleaseOverride = AutoDeployReleaseOverrides.SingleOrDefault(x => x.EnvironmentId == environment.Id && x.TenantId == tenant?.Id);
if (existingAutoDeployReleaseOverride != null)
{
AutoDeployReleaseOverrides.Remove(existingAutoDeployReleaseOverride);
}
AutoDeployReleaseOverrides.Add(autoDeployReleaseOverrideResource);
}
public void SetUp()
{
createAutoDeployOverrideCommand = new CreateAutoDeployOverrideCommand(RepositoryFactory, Log, FileSystem, ClientFactory);
environment = new EnvironmentResource { Name = "Production", Id = "Environments-001" };
project = new ProjectResource("Projects-1", "OctoFx", "OctoFx");
release = new ReleaseResource("1.2.0", "Projects-1", "Channels-1");
octopusTenant = new TenantResource
{
Id = "Tenants-1",
Name = "Octopus",
ProjectEnvironments = { ["Projects-1"] = new ReferenceCollection("Environments-001") }
};
Repository.Environments.FindByName("Production").Returns(
environment
);
Repository.Projects.FindByName("OctoFx").Returns(
project
);
Repository.Projects.GetReleaseByVersion(Arg.Any<ProjectResource>(), "1.2.0").Returns(
release
);
Repository.Tenants.FindByNames(Arg.Any<IEnumerable<string>>()).Returns(
new List<TenantResource>
{
octopusTenant
}
);
Repository.Tenants.FindAll(null, Arg.Any<string[]>()).Returns(
new List<TenantResource>
{
octopusTenant
}
);
Repository.Projects.When(x => x.Modify(Arg.Any<ProjectResource>()))
.Do(x => savedProject = x.Args()[0] as ProjectResource);
}
private async Task<DeploymentResource> CreateDeploymentTask(ProjectResource project, ReleaseResource release, DeploymentPromotionTarget promotionTarget, ReferenceCollection specificMachineIds, TenantResource tenant = null)
{
var preview = await Repository.Releases.GetPreview(promotionTarget).ConfigureAwait(false);
// Validate skipped steps
var skip = new ReferenceCollection();
foreach (var step in SkipStepNames)
{
var stepToExecute =
preview.StepsToExecute.SingleOrDefault(s => string.Equals(s.ActionName, step, StringComparison.CurrentCultureIgnoreCase));
if (stepToExecute == null)
{
Log.Warning("No step/action named '{Step:l}' could be found when deploying to environment '{Environment:l}', so the step cannot be skipped.", step, promotionTarget.Name);
}
else
{
Log.Debug("Skipping step: {Step:l}", stepToExecute.ActionName);
skip.Add(stepToExecute.ActionId);
}
}
// Validate form values supplied
if (preview.Form != null && preview.Form.Elements != null && preview.Form.Values != null)
{
foreach (var element in preview.Form.Elements)
{
var variableInput = element.Control as VariableValue;
if (variableInput == null)
{
continue;
}
var value = variables.Get(variableInput.Label) ?? variables.Get(variableInput.Name);
if (string.IsNullOrWhiteSpace(value) && element.IsValueRequired)
{
throw new ArgumentException("Please provide a variable for the prompted value " + variableInput.Label);
}
preview.Form.Values[element.Name] = value;
}
}
// Log step with no machines
foreach (var previewStep in preview.StepsToExecute)
{
if (previewStep.HasNoApplicableMachines)
{
Log.Warning("Warning: there are no applicable machines roles used by step {Step:l}", previewStep.ActionName);
}
}
var deployment = await Repository.Deployments.Create(new DeploymentResource
{
TenantId = tenant?.Id,
EnvironmentId = promotionTarget.Id,
SkipActions = skip,
ReleaseId = release.Id,
ForcePackageDownload = ForcePackageDownload,
UseGuidedFailure = UseGuidedFailure.GetValueOrDefault(preview.UseGuidedFailureModeByDefault),
SpecificMachineIds = specificMachineIds,
ForcePackageRedeployment = ForcePackageRedeployment,
FormValues = (preview.Form ?? new Form()).Values,
QueueTime = DeployAt == null ? null : (DateTimeOffset?) DeployAt.Value
})
.ConfigureAwait(false);
Log.Information("Deploying {Project:l} {Release:} to: {PromotionTarget:l} {Tenant:l}(Guided Failure: {GuidedFailure:l})", project.Name, release.Version, promotionTarget.Name,
tenant == null ? string.Empty : $"for {tenant.Name} ",
deployment.UseGuidedFailure ? "Enabled" : "Not Enabled");
return deployment;
}
public MachineResource RemoveTenant(TenantResource tenant)
{
TenantIds.Remove(tenant.Id);
return(this);
}
void AddOverrideForTenant(ProjectResource project, EnvironmentResource environment, TenantResource tenant, ReleaseResource release)
{
if (!tenant.ProjectEnvironments.ContainsKey(project.Id))
{
Log.Warning("The tenant {Tenant:l} was skipped because it has not been connected to the project {Project:l}", tenant.Name, project.Name);
return;
}
if (!tenant.ProjectEnvironments[project.Id].Contains(environment.Id))
{
Log.Warning("The tenant {Tenant:l} was skipped because it has not been connected to the environment {Environment:l}", tenant.Name, environment.Name);
return;
}
project.AddAutoDeployReleaseOverride(environment, tenant, release);
Log.Information("Auto deploy will deploy version {Version:l} of the project {Project:l} to the environment {Environment:l} for the tenant {Tenant:l}", release.Version, project.Name, environment.Name, tenant.Name);
}
public MachineResource RemoveTenant(TenantResource tenant)
{
TenantIds.Remove(tenant.Id);
return this;
}
public void ShouldTryLoadTenant()
{
var tenant1 = new TenantResource() { Id = "Tenant-1", Name = "Tenant One" };
Repository.Tenants
.Get(Arg.Is<string[]>(t => t.SequenceEqual(new[] { "Tenant-1" })))
.Returns(new List<TenantResource>() { tenant1 });
taskResource.State = TaskState.Success;
CommandLineArgs.Add("--project=" + ProjectName);
CommandLineArgs.Add("--deploymenttimeout=00:00:01");
CommandLineArgs.Add("--deployto=TestEnvironment");
CommandLineArgs.Add("--tenant=*");
CommandLineArgs.Add("--version=latest");
CommandLineArgs.Add("--progress");
CommandLineArgs.Add("--cancelontimeout");
deployReleaseCommand.Execute(CommandLineArgs.ToArray()).GetAwaiter().GetResult();
Repository.Deployments.Received(1).Create(Arg.Any<DeploymentResource>());
Repository.Deployments.Received()
.Create(Arg.Is<DeploymentResource>(dr => dr.TenantId == tenant1.Id && dr.EnvironmentId == "Env-1"));
}
private void DeleteOverrideForTenant(ProjectResource project, EnvironmentResource environment, TenantResource tenant)
{
var autoDeployOverride = project.AutoDeployReleaseOverrides.SingleOrDefault(
o => o.EnvironmentId == environment.Id && o.TenantId == tenant.Id);
if (autoDeployOverride == null)
{
Log.Warning("Did not find an auto deploy override for the project {Project:l}, environment {Environment:l} and tenant {Tenant:l}", project.Name, environment.Name, tenant.Name);
}
else
{
project.AutoDeployReleaseOverrides.Remove(autoDeployOverride);
Log.Information("Deleted auto deploy release override for the project {Project:l} to the environment {Environment:l} and tenant {Tenant:l}", project.Name, environment.Name, tenant.Name);
}
}
