public async Task Request()
{
project = await RepositoryCommonQueries.GetProjectByName(ProjectName).ConfigureAwait(false);
releaseTask = RepositoryCommonQueries.GetReleaseByVersion(ReleaseVersionNumber, project, null).ConfigureAwait(false);
tenants = await RepositoryCommonQueries.FindTenants(TenantNames, TenantTags).ConfigureAwait(false);
release = await releaseTask;
foreach (var environmentName in EnvironmentNames)
{
environment = await RepositoryCommonQueries.GetEnvironmentByName(environmentName).ConfigureAwait(false);
if (!tenants.Any())
{
AddOverrideForEnvironment(project, environment, release);
}
else
{
foreach (var tenant in tenants)
{
AddOverrideForTenant(project, environment, tenant, release);
}
}
}
await Repository.Projects.Modify(project).ConfigureAwait(false);
}
async Task <OctopusJiraPayloadData> PrepareOctopusJiraPayload(string eventType,
string serverUri,
DeploymentResource deployment,
IJiraApiDeployment jiraApiDeployment,
CancellationToken cancellationToken,
EnvironmentResource deploymentEnvironment,
DeploymentEnvironmentSettingsMetadataProvider.JiraDeploymentEnvironmentSettings
environmentSettings)
{
var project = (await mediator.Request(new GetProjectRequest(deployment.ProjectId), cancellationToken)).Project;
var release = (await mediator.Request(new GetReleaseRequest(deployment.ReleaseId), cancellationToken)).Release;
var serverTask = (await mediator.Request(new GetServerTaskRequest(deployment.TaskId), cancellationToken)).Task;
TenantResource?tenant = null;
if (deployment.TenantId?.Value is not null)
{
tenant = (await mediator.Request(new GetTenantByIdOrNameRequest(deployment.TenantId.Value.ToTenantIdOrName()), cancellationToken)).Resource;
}
return(new OctopusJiraPayloadData
{
InstallationId = installationIdProvider.GetInstallationId().ToString(),
BaseHostUrl = store.GetBaseUrl() ?? string.Empty,
DeploymentsInfo = new JiraPayloadData
{
Deployments = new[]
/// <summary>
/// Get the DeploymentResource at the input environment of specific release version.
/// If the version is not specified, it will return the last deployment at the input environment
/// </summary>
/// <param name="env"></param>
/// <param name="releaseResource"></param>
/// <returns></returns>
public DeploymentResource GetDeployment(EnvironmentResource env, ReleaseResource releaseResource = null)
{
if (releaseResource != null)
{
return(GetAllDeployment(releaseResource).FirstOrDefault(deployment => deployment.EnvironmentId
== env.Id));
}
DeploymentResource lastDeployment = null;
foreach (var release in GetAllReleases().Take(int.Parse(ConfigurationManager
.AppSettings["ReleasesSelectionRange"])))
{
var deploy = GetAllDeployment(release).FirstOrDefault(deployment => deployment.EnvironmentId == env.Id);
if (deploy == null)
{
continue;
}
if (lastDeployment == null)
{
lastDeployment = deploy;
}
if (deploy.Created > lastDeployment.Created)
{
lastDeployment = deploy;
}
}
return(lastDeployment);
}
public async Task Request()
{
project = await Repository.Projects.FindByNameOrIdOrFail(ProjectNameOrId).ConfigureAwait(false);
environment = await Repository.Environments.FindByNameOrIdOrFail(FromEnvironmentNameOrId).ConfigureAwait(false);
var dashboard = await Repository.Dashboards.GetDynamicDashboard(new[] { project.Id }, new[] { environment.Id }).ConfigureAwait(false);
var dashboardItem = dashboard.Items.Where(e => e.EnvironmentId == environment.Id && e.ProjectId == project.Id)
.OrderByDescending(i => SemanticVersion.Parse(i.ReleaseVersion))
.FirstOrDefault();
if (dashboardItem == null)
{
throw new CouldNotFindException("latest deployment of the project for this environment. Please check that a deployment for this project/environment exists on the dashboard.");
}
commandOutputProvider.Debug("Finding release details for release {Version:l}", dashboardItem.ReleaseVersion);
release = await Repository.Projects.GetReleaseByVersion(project, dashboardItem.ReleaseVersion).ConfigureAwait(false);
if (UpdateVariableSnapshot)
{
commandOutputProvider.Debug("Updating the release variable snapshot with variables from the project");
await Repository.Releases.SnapshotVariables(release).ConfigureAwait(false);
}
await DeployRelease(project, release).ConfigureAwait(false);
}
private void CleanUpEnvironment(List <MachineResource> filteredMachines, EnvironmentResource environmentResource)
{
Log.Information("Found {MachineCount} machines in {Environment:l} with the status {Status:l}", filteredMachines.Count, environmentResource.Name, GetStateFilterDescription());
if (filteredMachines.Any(m => m.EnvironmentIds.Count > 1))
{
Log.Information("Note: Some of these machines belong to multiple environments. Instead of being deleted, these machines will be removed from the {Environment:l} environment.", environmentResource.Name);
}
foreach (var machine in filteredMachines)
{
// If the machine belongs to more than one environment, we should remove the machine from the environment rather than delete it altogether.
if (machine.EnvironmentIds.Count > 1)
{
Log.Information("Removing {Machine:l} {Status} (ID: {Id:l}) from {Environment:l}", machine.Name, machine.Status, machine.Id,
environmentResource.Name);
machine.EnvironmentIds.Remove(environmentResource.Id);
Repository.Machines.Modify(machine);
}
else
{
Log.Information("Deleting {Machine:l} {Status} (ID: {Id:l})", machine.Name, machine.Status, machine.Id);
Repository.Machines.Delete(machine);
}
}
}
private EnvironmentResource[] CreateEnvironments(int prefix, IReadOnlyList <MachineResource> machines)
{
var envs = new EnvironmentResource[EnvironmentsPerGroup.Get()];
Enumerable.Range(1, envs.Length)
.AsParallel()
.ForAll(e =>
{
var name = $"Env-{prefix:000}-{e}";
var envRes = Repository.Environments.FindByName(name);
envs[e - 1] = envRes ?? Repository.Environments.Create(new EnvironmentResource()
{
Name = name
});
});
lock (this)
{
foreach (var env in envs)
{
if (machines.Any())
{
var machine = machines[Program.Rnd.Next(0, machines.Count)];
Repository.Machines.Refresh(machine);
machine.EnvironmentIds.Add(env.Id);
Repository.Machines.Modify(machine);
}
}
}
return(envs);
}
protected override void ProcessRecord()
{
object baseresource = null;
switch (Resource)
{
case "Environment":
baseresource = new EnvironmentResource();
break;
case "Project":
baseresource = new ProjectResource();
break;
case "ProjectGroup":
baseresource = new ProjectGroupResource();
break;
case "NugetFeed":
case "ExternalFeed":
baseresource = new NuGetFeedResource();
break;
case "LibraryVariableSet":
baseresource = new LibraryVariableSetResource();
break;
case "Machine":
case "Target":
baseresource = new MachineResource();
break;
case "Lifecycle":
baseresource = new LifecycleResource();
break;
case "Team":
baseresource = new TeamResource();
break;
case "User":
baseresource = new UserResource();
break;
case "Channel":
baseresource = new ChannelResource();
break;
case "Tenant":
baseresource = new TenantResource();
break;
case "TagSet":
baseresource = new TagSetResource();
break;
}
WriteObject(baseresource);
}
public static DeploymentEnvironment ToDeploymentEnvironment(this EnvironmentResource environment)
{
return(new DeploymentEnvironment
{
EnvironmentId = environment.Id,
Name = environment.Name,
});
}
public async Task <IActionResult> SyncReleaseBatch([FromRoute] string idOrName, [FromBody] string environmentIdOrName = null)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var releaseBatch = await GetReleaseBatch(idOrName, true, false);
if (releaseBatch == null)
{
return(NotFound());
}
if (releaseBatch.IsLocked)
{
return(GetLockedForbiddenUpdateResult(releaseBatch));
}
if (releaseBatch.Items != null && releaseBatch.Items.Any())
{
EnvironmentResource environment = null;
if (!String.IsNullOrEmpty(environmentIdOrName))
{
environment = await _octopusProxy.GetEnvironmentAsync(environmentIdOrName);
if (environment == null)
{
return(BadRequest("Environment Not Found"));
}
}
foreach (var releaseBatchItem in releaseBatch.Items)
{
var releaseResource =
await
(environment == null
? _octopusProxy.GetLatestReleaseAsync(releaseBatchItem.ProjectId)
: _octopusProxy.GetLatestDeployedReleaseAsync(releaseBatchItem.ProjectId, environment.Id));
releaseBatchItem.ReleaseId = releaseResource?.Id;
releaseBatchItem.ReleaseVersion = releaseResource?.Version;
var projectResource = await _octopusProxy.GetProjectAsync(releaseBatchItem.ProjectId);
releaseBatchItem.ProjectName = projectResource.Name;
releaseBatchItem.ProjectSlug = projectResource.Slug;
}
releaseBatch.SyncDateTime = DateTimeOffset.Now;
releaseBatch.SyncEnvironmentId = environment?.Id;
releaseBatch.SyncEnvironmentName = environment?.Name ?? "(Latest)";
releaseBatch.SyncUserName = User.Identity.Name;
}
await _context.SaveChangesAsync();
return(Ok(releaseBatch));
}
public void SetUp()
{
createAutoDeployOverrideCommand = new CreateAutoDeployOverrideCommand(RepositoryFactory, FileSystem, ClientFactory, CommandOutputProvider);
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");
release2 = new ReleaseResource("somedockertag", "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.Projects.GetReleaseByVersion(Arg.Any <ProjectResource>(), "somedockertag")
.Returns(
release2
);
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);
}
public async Task <Environment> CreateEnvironment(string name, string description)
{
var env = new EnvironmentResource {
Name = name,
Description = description
};
env = await client.Repository.Environments.Create(env);
return(ConvertEnvironment(env));
}
public void Initialize()
{
_octopus = new OctopusRepository(new OctopusServerEndpoint(_serverAddress, _apiKey));
// Get Production Environment
_prodEnv = _octopus.Environments.FindByName(_environmentName);
if (_prodEnv == null)
{
_logger.WriteError($"Could not find environment '{_environmentName}'");
}
}
/// <summary>
/// Creates an Environment
/// </summary>
/// <param name="octRepository">The repository to call against.</param>
/// <param name="name">Name of the new Environment.</param>
/// <param name="description">Description of the new Environment.</param>
/// <param name="guidedFailure">Auto Enable GuidedFailure on Environment.</param>
/// <returns>EnvironmentResource.</returns>
public static EnvironmentResource CreateEnvironment(OctopusRepository octRepository, string name, string description, bool guidedFailure)
{
var environmentToCreate = new EnvironmentResource()
{
Name = name,
UseGuidedFailure = guidedFailure,
Description = description
};
return(octRepository.Environments.Create(environmentToCreate));
}
/// <summary>
/// Promote Release from one environment to another. If the releaseVersion is not specified.
/// The release has the latest deployment at sourceEnv will be chosen to deploy to the targetEnv.
/// Skip creating the deployment if there is no release at the input Env
/// </summary>
/// <param name="project"></param>
/// <param name="sourceEnv"></param>
/// <param name="settings"></param>
/// <returns></returns>
public static DeploymentResource PromoteRelease(OctoProject project, EnvironmentResource sourceEnv,
SingleReleasePromotingSettings settings)
{
if (settings.Release == null)
{
var releaseRepo = WebClient.GetWebClientRef().GetReleaseRepo();
var sourceDeploy = project.GetDeployment(sourceEnv);
settings.Release = sourceDeploy == null ? null : releaseRepo.Get(sourceDeploy.ReleaseId);
}
return(settings.Release == null ? null : CreateDeployment(project, settings.Release,
new SingleProjectDeploymentSettings(settings)));
}
/// <summary>
/// Builds a base deployment with all steps enabled for the passed environment and release.
/// </summary>
/// <param name="release">Release to deploy.</param>
/// <param name="environment">Environment to deploy to.</param>
/// <param name="comment">Comment for the deployment.</param>
/// <param name="guidedFailure">Enable Guided Failure.</param>
/// <returns>DeploymentResource</returns>
public static DeploymentResource BuildDeployment(ReleaseResource release, EnvironmentResource environment, string comment, bool guidedFailure)
{
var deploymentResource = new DeploymentResource
{
EnvironmentId = environment.Id,
ReleaseId = release.Id,
ForcePackageDownload = false,
UseGuidedFailure = guidedFailure,
ForcePackageRedeployment = true,
Comments = comment
};
return(deploymentResource);
}
public async Task JsonOutput_ShouldBeWellFormed()
{
var environmentResource = new EnvironmentResource {
Name = "Development", Id = "Environments-001"
};
Repository.Environments.FindByName("Development").Returns(environmentResource);
CommandLineArgs.Add("--outputFormat=json");
CommandLineArgs.Add($"--environment={environmentResource.Name}");
CommandLineArgs.Add("-status=Offline");
var machineList = new List <MachineResource>
{
new MachineResource
{
Name = "PC01466",
Id = "Machines-002",
Status = MachineModelStatus.Offline,
EnvironmentIds = new ReferenceCollection(new[] { "Environments-001", "Environments-002" })
},
new MachineResource
{
Name = "PC01996",
Id = "Machines-003",
Status = MachineModelStatus.Offline,
EnvironmentIds = new ReferenceCollection("Environments-001")
}
};
Repository.Machines.FindMany(Arg.Any <Func <MachineResource, bool> >()).Returns(machineList);
await listMachinesCommand.Execute(CommandLineArgs.ToArray()).ConfigureAwait(false);
var logoutput = LogOutput.ToString();
Console.WriteLine(logoutput);
JsonConvert.DeserializeObject(logoutput);
Regex.Matches(logoutput, CleanEnvironmentCommand.MachineAction.Deleted.ToString())
.Count.Should()
.Be(1, "should only have one deleted machine");
Regex.Matches(logoutput, CleanEnvironmentCommand.MachineAction.RemovedFromEnvironment.ToString())
.Count.Should()
.Be(1, "should only have one machine removed from the environment");
logoutput.Should().Contain(machineList[0].Name);
logoutput.Should().Contain(machineList[0].Id);
logoutput.Should().Contain(machineList[1].Name);
logoutput.Should().Contain(machineList[1].Id);
}
public void TestFetchResponse()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
twilioRestClient.AccountSid.Returns("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
twilioRestClient.Request(Arg.Any <Request>())
.Returns(new Response(
System.Net.HttpStatusCode.OK,
"{\"sid\": \"ZE00000000000000000000000000000000\",\"account_sid\": \"ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"service_sid\": \"ZS00000000000000000000000000000000\",\"build_sid\": \"ZB00000000000000000000000000000000\",\"unique_name\": \"testing-environment\",\"domain_suffix\": \"testing\",\"domain_name\": \"foobar-1234-testing.twil.io\",\"date_created\": \"2018-11-10T20:00:00Z\",\"date_updated\": \"2018-11-10T20:00:00Z\",\"url\": \"https://serverless.twilio.com/v1/Services/ZS00000000000000000000000000000000/Environments/ZE00000000000000000000000000000000\",\"links\": {\"variables\": \"https://serverless.twilio.com/v1/Services/ZS00000000000000000000000000000000/Environments/ZE00000000000000000000000000000000/Variables\",\"deployments\": \"https://serverless.twilio.com/v1/Services/ZS00000000000000000000000000000000/Environments/ZE00000000000000000000000000000000/Deployments\",\"logs\": \"https://serverless.twilio.com/v1/Services/ZS00000000000000000000000000000000/Environments/ZE00000000000000000000000000000000/Logs\"}}"
));
var response = EnvironmentResource.Fetch("ZSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "ZEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", client: twilioRestClient);
Assert.NotNull(response);
}
public void TestReadEmptyResponse()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
twilioRestClient.AccountSid.Returns("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
twilioRestClient.Request(Arg.Any <Request>())
.Returns(new Response(
System.Net.HttpStatusCode.OK,
"{\"environments\": [],\"meta\": {\"first_page_url\": \"https://serverless.twilio.com/v1/Services/ZS00000000000000000000000000000000/Environments?PageSize=50&Page=0\",\"key\": \"environments\",\"next_page_url\": null,\"page\": 0,\"page_size\": 50,\"previous_page_url\": null,\"url\": \"https://serverless.twilio.com/v1/Services/ZS00000000000000000000000000000000/Environments?PageSize=50&Page=0\"}}"
));
var response = EnvironmentResource.Read("ZSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", client: twilioRestClient);
Assert.NotNull(response);
}
private void DeleteOverrideForEnvironment(ProjectResource project, EnvironmentResource environment)
{
var autoDeployOverride = project.AutoDeployReleaseOverrides.SingleOrDefault(
o => o.EnvironmentId == environment.Id && o.TenantId == null);
if (autoDeployOverride == null)
{
Log.Warning("Did not find an auto deploy override for the project {Project:l} and environment {Environment:l}", project.Name, environment.Name);
}
else
{
project.AutoDeployReleaseOverrides.Remove(autoDeployOverride);
Log.Information("Deleted auto deploy release override for the project {Project:l} to the environment {Environment:l}", project.Name, environment.Name);
}
}
public void TestDeleteResponse()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
twilioRestClient.AccountSid.Returns("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
twilioRestClient.Request(Arg.Any <Request>())
.Returns(new Response(
System.Net.HttpStatusCode.NoContent,
"null"
));
var response = EnvironmentResource.Delete("ZSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "ZEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", client: twilioRestClient);
Assert.NotNull(response);
}
public void CreateAndRemoveEnvironment()
{
#region EnvironmentCreate
var resource = new EnvironmentResource {
Name = TestResourceName
};
var createParameters = new List <CmdletParameter>
{
new CmdletParameter()
{
Name = "Resource",
Resource = resource
}
};
var createPowershell = new CmdletRunspace().CreatePowershellcmdlet(CreateCmdletName, CreateCmdletType, createParameters);
//The fact that the line below doesn't throw is enough to prove that the cmdlet returns the expected object type really. Couldn't figure out a way to make the assert around the Powershell.invoke call
var createResult = createPowershell.Invoke <EnvironmentResource>().FirstOrDefault();
if (createResult != null)
{
Assert.AreEqual(createResult.Name, TestResourceName);
Console.WriteLine("Created resource [{0}] of type [{1}]", createResult.Name, createResult.GetType());
}
#endregion
#region EnvironmentDelete
var removeParameters = new List <CmdletParameter>
{
new CmdletParameter()
{
Name = "Resource",
Resource = createResult
}
};
var removePowershell = new CmdletRunspace().CreatePowershellcmdlet(RemoveCmdletName, RemoveCmdletType);
var removeResult = removePowershell.Invoke <bool>(removeParameters).FirstOrDefault();
Assert.IsTrue(removeResult);
Console.WriteLine("Deleted resource [{0}] of type [{1}]", createResult.Name, createResult.GetType());
#endregion
}
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);
}
private static void CreateAccount(EnvironmentResource environment, string accountName, xAccountType accountType)
{
var accountExists = _repository.Accounts.FindByName(accountName).Result;
AccountResource account = null;
switch (accountType)
{
case xAccountType.SSH:
account = new SshKeyPairAccountResource()
{
Id = accountExists?.Id,
Name = accountName,
EnvironmentIds = new ReferenceCollection(environment.Id),
PrivateKeyFile = new SensitiveValue()
{
HasValue = true, NewValue = "stuff"
},
Description = GeneralResourceProperty.ResourceDescription,
Username = "******",
Links = accountExists?.Links
};
break;
default:
break;
}
try
{
Log.Information($"Creating/Modifying Account [{account.Name}]");
if (account.Id == null)
{
_repository.Accounts.Create(account).Wait();
}
else
{
_repository.Accounts.Modify(account).Wait();
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private EnvironmentResource[] CreateEnvironments(int prefix)
{
var envs = new EnvironmentResource[EnvironmentsPerGroup.Get()];
Enumerable.Range(1, envs.Length)
.AsParallel()
.ForAll(e =>
{
var name = $"Env-{prefix:000}-{e}";
var envRes = Repository.Environments.FindByName(name);
envs[e - 1] = envRes ?? Repository.Environments.Create(new EnvironmentResource()
{
Name = name
});
});
return(envs);
}
public async Task Request()
{
if (string.IsNullOrWhiteSpace(environmentName))
{
throw new CommandException("Please specify an environment name using the parameter: --environment=XYZ");
}
if (!healthStatuses.Any() && !statuses.Any())
{
throw new CommandException("Please specify a status using the parameter: --status or --health-status");
}
environmentResource = await GetEnvironment().ConfigureAwait(false);
machines = await FilterByEnvironment(environmentResource).ConfigureAwait(false);
machines = await FilterByState(machines);
await CleanUpEnvironment(machines.ToList(), environmentResource);
}
void DeleteOverrideForEnvironment(ProjectResource project, EnvironmentResource environment)
{
var autoDeployOverride = project.AutoDeployReleaseOverrides.SingleOrDefault(
o => o.EnvironmentId == environment.Id && o.TenantId == null);
if (autoDeployOverride == null)
{
deletedDeplomentOverrides.Add(
new Tuple <EnvironmentResource, TenantResource, DeletedOutcome>(environment, null, DeletedOutcome.NotFound));
commandOutputProvider.Warning("Did not find an auto deploy override for the project {Project:l} and environment {Environment:l}", project.Name, environment.Name);
}
else
{
deletedDeplomentOverrides.Add(
new Tuple <EnvironmentResource, TenantResource, DeletedOutcome>(environment, null, DeletedOutcome.Deleted));
project.AutoDeployReleaseOverrides.Remove(autoDeployOverride);
commandOutputProvider.Information("Deleted auto deploy release override for the project {Project:l} to the environment {Environment:l}", project.Name, environment.Name);
}
}
void AddOverrideForTenant(ProjectResource project, EnvironmentResource environment, TenantResource tenant, ReleaseResource release)
{
if (!tenant.ProjectEnvironments.ContainsKey(project.Id))
{
createdDeploymentOverides.Add(new Tuple <EnvironmentResource, TenantResource, CreatedOutcome>(environment, tenant, CreatedOutcome.NotConnectedToProject));
commandOutputProvider.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))
{
createdDeploymentOverides.Add(new Tuple <EnvironmentResource, TenantResource, CreatedOutcome>(environment, tenant, CreatedOutcome.NotConnectedToEnvironment));
commandOutputProvider.Warning("The tenant {Tenant:l} was skipped because it has not been connected to the environment {Environment:l}", tenant.Name, environment.Name);
return;
}
createdDeploymentOverides.Add(new Tuple <EnvironmentResource, TenantResource, CreatedOutcome>(environment, tenant, CreatedOutcome.Created));
project.AddAutoDeployReleaseOverride(environment, tenant, release);
commandOutputProvider.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 void TestFetchRequest()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
var request = new Request(
HttpMethod.Get,
Twilio.Rest.Domain.Serverless,
"/v1/Services/ZSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Environments/ZEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
""
);
twilioRestClient.Request(request).Throws(new ApiException("Server Error, no content"));
try
{
EnvironmentResource.Fetch("ZSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "ZEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", client: twilioRestClient);
Assert.Fail("Expected TwilioException to be thrown for 500");
}
catch (ApiException) {}
twilioRestClient.Received().Request(request);
}
public void TestCreateRequest()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
var request = new Request(
HttpMethod.Post,
Twilio.Rest.Domain.Serverless,
"/v1/Services/ZSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Environments",
""
);
request.AddPostParam("UniqueName", Serialize("unique_name"));
twilioRestClient.Request(request).Throws(new ApiException("Server Error, no content"));
try
{
EnvironmentResource.Create("ZSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "unique_name", client: twilioRestClient);
Assert.Fail("Expected TwilioException to be thrown for 500");
}
catch (ApiException) {}
twilioRestClient.Received().Request(request);
}
public async Task Request()
{
project = await Repository.Projects.FindByNameOrIdOrFail(ProjectNameOrId).ConfigureAwait(false);
environment = await Repository.Environments.FindByNameOrIdOrFail(FromEnvironmentNameOrId).ConfigureAwait(false);
var dashboardItemsOptions = UseLatestSuccessfulRelease
? DashboardItemsOptions.IncludeCurrentAndPreviousSuccessfulDeployment
: DashboardItemsOptions.IncludeCurrentDeploymentOnly;
var dashboard = await Repository.Dashboards.GetDynamicDashboard(new[] { project.Id }, new[] { environment.Id }, dashboardItemsOptions).ConfigureAwait(false);
var dashboardItems = dashboard.Items
.Where(e => e.EnvironmentId == environment.Id && e.ProjectId == project.Id)
.OrderByDescending(i => SemanticVersion.Parse(i.ReleaseVersion));
var dashboardItem = UseLatestSuccessfulRelease
? dashboardItems.FirstOrDefault(x => x.State == TaskState.Success)
: dashboardItems.FirstOrDefault();
if (dashboardItem == null)
{
var deploymentType = UseLatestSuccessfulRelease ? "successful " : "";
throw new CouldNotFindException($"latest {deploymentType}deployment of the project for this environment. Please check that a {deploymentType} deployment for this project/environment exists on the dashboard.");
}
commandOutputProvider.Debug("Finding release details for release {Version:l}", dashboardItem.ReleaseVersion);
release = await Repository.Projects.GetReleaseByVersion(project, dashboardItem.ReleaseVersion).ConfigureAwait(false);
if (UpdateVariableSnapshot)
{
commandOutputProvider.Debug("Updating the release variable snapshot with variables from the project");
await Repository.Releases.SnapshotVariables(release).ConfigureAwait(false);
}
await DeployRelease(project, release).ConfigureAwait(false);
}
