public static async Task Execute <T>(T options, IModifyReleaseOperation <T> operation) where T : ModifyReleaseParams
{
using (var client = await OctopusClientProvider.GetOctopusClient(options))
{
foreach (var projectStr in await options.GetEffectiveProjects(client))
{
var project = await client.Repository.Projects.FindByName(projectStr);
if (project == null)
{
Console.WriteLine($"Skipped {projectStr} as cannot find this project");
continue;
}
try
{
var release =
await client.Repository.Projects.GetReleaseByVersion(project,
options.ReleaseName);
if (release == null)
{
Console.WriteLine($"Skipped {projectStr} as cannot find the release for this project");
continue;
}
await operation.Execute(client, options, release);
}
catch (OctopusResourceNotFoundException)
{
Console.WriteLine($"Skipped {projectStr} as cannot find the release for this project");
}
}
}
}
protected override async Task Execute(ListMachinesParams options)
{
using (var client = await OctopusClientProvider.GetOctopusClient(options))
{
List <MachineResource> machines;
if (!string.IsNullOrWhiteSpace(options.Environment))
{
var env = await client.Repository.Environments.FindByName(options.Environment);
if (env == null)
{
Console.Error.WriteLine($"Environment {options.Environment} not found");
}
machines = await client.Repository.Environments.GetMachines(env);
}
else
{
machines = await client.Repository.Machines.FindAll();
}
var json = JsonConvert.SerializeObject(machines, Formatting.Indented);
Console.WriteLine(json);
}
}
protected override async Task Execute(CreateChannelParams options)
{
using (var client = await OctopusClientProvider.GetOctopusClient(options))
{
foreach (var projectStr in await options.GetEffectiveProjects(client))
{
var project = await client.Repository.Projects.FindByName(projectStr);
var channel = await client.GetChannelResource(project, options.Channel);
if (channel != null)
{
Console.WriteLine(
$"Skipped create channel {options.Channel} as it already exists in project {project.Name}");
continue;
}
Console.WriteLine($"Creating channel {options.Channel} in project {project.Name}");
var channelEditor = await client.Repository.Channels.CreateOrModify(project, options.Channel);
if (!string.IsNullOrWhiteSpace(options.LifeCycle))
{
var lifeCycle =
await client.Repository.Lifecycles.FindByName(options.LifeCycle.Trim());
channelEditor.UsingLifecycle(lifeCycle);
await channelEditor.Save();
}
}
}
}
protected override async Task Execute(ProjectsParams options)
{
using (var client = await OctopusClientProvider.GetOctopusClient(options))
{
var actions = await GetAllActionsFromProjects(options, client);
var packages = GetPackagesFromActions(actions);
OutputPackages(packages);
}
}
protected override async Task Execute(SetRolesParams options)
{
using (var client = await OctopusClientProvider.GetOctopusClient(options))
{
var machine = await client.Repository.Machines.Get(options.MachineId);
var envs = await client.Repository.Environments.Get(machine.EnvironmentIds.ToArray());
await client.Repository.Machines.CreateOrModify(machine.Name, machine.Endpoint,
envs.ToArray(), options.Roles.ToArray());
}
}
protected override async Task Execute(FindByThumbprintParams options)
{
using (var client = await OctopusClientProvider.GetOctopusClient(options))
{
var machines = await client.Repository.Machines.FindByThumbprint(options.Thumbprint);
if (!machines.Any())
{
Console.WriteLine("Machine not found");
}
foreach (var m in machines)
{
Console.WriteLine(m.Name);
}
}
}
public static async Task PromoteToChannel(CreateReleaseParams releaseParams)
{
using (var client = await OctopusClientProvider.GetOctopusClient(releaseParams))
{
foreach (var projectStr in await releaseParams.GetEffectiveProjects(client))
{
var project = await client.Repository.Projects.FindByName(projectStr);
if (project == null)
{
Console.WriteLine($"Skipped {projectStr} as cannot find this project");
continue;
}
var channel = await client.GetChannelResource(project, releaseParams.Channel);
if (channel == null)
{
Console.WriteLine($"Skipped {projectStr} as cannot find the channel for this project");
continue;
}
try
{
var release =
await client.Repository.Projects.GetReleaseByVersion(project,
releaseParams.GetEffectiveReleaseName());
if (release == null)
{
Console.WriteLine($"Skipped {projectStr} as cannot find the release for this project");
continue;
}
release.ChannelId = channel.Id;
await client.Repository.Releases.Modify(release);
}
catch (OctopusResourceNotFoundException)
{
Console.WriteLine($"Skipped {projectStr} as cannot find the release for this project");
continue;
}
}
}
}
public static async Task CreateRelease(CreateReleaseParams releaseParams)
{
using (var client = await OctopusClientProvider.GetOctopusClient(releaseParams))
{
var effectiveProjects = await releaseParams.GetEffectiveProjects(client);
if (!effectiveProjects.Any())
{
Console.Error.WriteLine("No project specified, please use the --project-group or --projects");
Environment.Exit(-1);
}
foreach (var project in effectiveProjects)
{
await CreateRelease(project, releaseParams, client);
}
}
}
protected override async Task Execute(EnvironmentDeletionParams options)
{
using (var client = await OctopusClientProvider.GetOctopusClient(options))
{
var environments = await client.Repository.Environments.FindMany(e =>
Regex.IsMatch(e.Name, options.EnvironmentNameRegex, RegexOptions.IgnoreCase));
var lifeCycles = await client.Repository.Lifecycles.FindAll();
await RemoveEnvFromLifecycles(lifeCycles, environments, client, options.DryRun);
// ReSharper disable once AccessToDisposedClosure
foreach (var env in environments)
{
await DeleteEnvironment(client, env, options.DryRun).ConfigureAwait(false);
}
}
}
protected override async Task Execute(ChannelParams options)
{
using (var client = await OctopusClientProvider.GetOctopusClient(options))
{
foreach (var projectStr in await options.GetEffectiveProjects(client))
{
var project = await client.Repository.Projects.FindByName(projectStr);
var channel = await client.GetChannelResource(project, options.Channel);
if (channel == null)
{
Console.WriteLine(
$"Skipped deleting channel {options.Channel} as it doesn't exist in project {project.Name}");
continue;
}
Console.WriteLine($"Deleting channel {options.Channel} from project {project.Name}");
try
{
await client.Repository.Channels.Delete(channel);
}
catch (OctopusValidationException ex)
{
if (ex.Message.Contains("This channel has releases including"))
{
Console.WriteLine($"Unable to delete channel for {project.Name}: {ex.Message}");
}
else
{
throw;
}
}
}
}
}
protected override async Task Execute(DeployParams options)
{
using (var client = await OctopusClientProvider.GetOctopusClient(options))
{
var env = await GetEnvironment(client, options.Environment);
var machines = await GetActiveMachines(client, env);
var project = await client.Repository.Projects.FindByName(options.Project);
var release = await client.Repository.Projects.GetReleaseByVersion(project, options.Version);
foreach (var machine in machines)
{
if (machine.IsDisabled)
{
Console.WriteLine($"Skipping disabled {machine.Name}, {machine.Id}");
continue;
}
if (machine.HealthStatus != MachineModelHealthStatus.Healthy &&
machine.HealthStatus != MachineModelHealthStatus.HasWarnings)
{
Console.WriteLine($"Skipping unhealthy {machine.Name}, {machine.Id}");
continue;
}
if (!await CanDeployToMachineCheckingRoles(client, machine, release, env.Id))
{
Console.WriteLine("Machine doesn't have required roles");
continue;
}
Console.WriteLine($"Deploying to {machine.Name}, {machine.Id}");
var depResource = new DeploymentResource
{
Comments =
$"Individually deploy project to machines in environment {options.Environment}",
TenantId = null,
EnvironmentId = env.Id,
SkipActions = new ReferenceCollection(),
ReleaseId = release.Id,
ForcePackageDownload = false,
UseGuidedFailure = false,
SpecificMachineIds = new ReferenceCollection(machine.Id),
ForcePackageRedeployment = false,
FormValues = new Dictionary <string, string>(),
QueueTime = null
};
try
{
await client.Repository.Deployments.Create(depResource);
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
}
if (options.SleepSeconds > 0)
{
Thread.Sleep(TimeSpan.FromSeconds(options.SleepSeconds));
}
}
}
}
protected override async Task Execute(DeleteReleasesByRangeParams options)
{
if (!SemanticVersion.TryParse(options.FromVersion, out var from))
{
Console.Error.WriteLine($"Invalid 'from' version: {options.FromVersion}");
return;
}
if (!SemanticVersion.TryParse(options.ToVersion, out var to))
{
Console.Error.WriteLine($"Invalid 'to' version: {options.ToVersion}");
return;
}
using (var client = await OctopusClientProvider.GetOctopusClient(options))
{
foreach (var projectStr in await options.GetEffectiveProjects(client))
{
var project = await client.Repository.Projects.FindByName(projectStr);
if (project == null)
{
Console.WriteLine($"Skipped {projectStr} as cannot find this project");
continue;
}
var releases =
await client.Repository.Projects.GetAllReleases(project);
if (releases == null || !releases.Any())
{
Console.WriteLine($"Skipped {projectStr} as cannot find the release for this project");
continue;
}
foreach (var release in releases)
{
if (!SemanticVersion.TryParse(release.Version, out var current))
{
Console.WriteLine(
$"Skipped deleteing a version for project {projectStr} as unable to interpret version: {release.Version}");
continue;
}
if (current < from || current > to)
{
continue;
}
Console.WriteLine($"Deleting {release.Version} for project {projectStr}");
try
{
await client.Repository.Releases.Delete(release);
}
catch (OctopusResourceNotFoundException)
{
Console.WriteLine($"Skipped {projectStr} as cannot find the release for this project");
}
}
}
}
}
