private async Task <IReadOnlyList <DeploymentResource> > DeployToEnvironments(ProjectResource project, ReleaseResource release)
{
if (DeployToEnvironmentNames.Count == 0)
{
return(new List <DeploymentResource>());
}
var releaseTemplate = await Repository.Releases.GetTemplate(release).ConfigureAwait(false);
var promotingEnvironments =
(from environment in DeployToEnvironmentNames.Distinct(StringComparer.CurrentCultureIgnoreCase)
let promote = releaseTemplate.PromoteTo.FirstOrDefault(p => string.Equals(p.Name, environment, StringComparison.CurrentCultureIgnoreCase))
select new { Name = environment, Promotion = promote }).ToList();
var unknownEnvironments = promotingEnvironments.Where(p => p.Promotion == null).ToList();
if (unknownEnvironments.Count > 0)
{
throw new CommandException(
string.Format(
"Release '{0}' of project '{1}' cannot be deployed to {2} not in the list of environments that this release can be deployed to. This may be because a) the environment does not exist or is misspelled, b) The lifecycle has not reached this phase, possibly due to previous deployment failure, c) you don't have permission to deploy to this environment, or d) the environment is not in the list of environments defined by the lifecycle.",
release.Version,
project.Name,
unknownEnvironments.Count == 1
? "environment '" + unknownEnvironments[0].Name + "' because the environment is"
: "environments " + string.Join(", ", unknownEnvironments.Select(e => "'" + e.Name + "'")) +
" because the environments are"
));
}
LogScheduledDeployment();
var specificMachineIds = await GetSpecificMachines().ConfigureAwait(false);
var excludedMachineIds = await GetExcludedMachines().ConfigureAwait(false);
var createTasks = promotingEnvironments.Select(promotion => CreateDeploymentTask(project, release, promotion.Promotion, specificMachineIds, excludedMachineIds));
return(await Task.WhenAll(createTasks).ConfigureAwait(false));
}
protected override async Task ValidateParameters()
{
if (string.IsNullOrWhiteSpace(ProjectName))
{
throw new CommandException("Please specify a project name using the parameter: --project=XYZ");
}
if (IsTenantedDeployment && DeployToEnvironmentNames.Count > 1)
{
throw new CommandException("Please specify only one environment at a time when deploying to tenants.");
}
if (Tenants.Contains("*") && (Tenants.Count > 1 || TenantTags.Count > 0))
{
throw new CommandException("When deploying to all tenants using --tenant=* wildcard no other tenant filters can be provided");
}
if (IsTenantedDeployment && !await Repository.SupportsTenants().ConfigureAwait(false))
{
throw new CommandException("Your Octopus Server does not support tenants, which was introduced in Octopus 3.4. Please upgrade your Octopus Server, enable the multi-tenancy feature or remove the --tenant and --tenanttag arguments.");
}
if ((DeployAt ?? DateTimeOffset.Now) > NoDeployAfter)
{
throw new CommandException("The deployment will expire before it has a chance to execute. Please select an expiry time that occurs after the deployment is scheduled to begin");
}
/*
* A create release operation can also optionally deploy the release, however any invalid options that
* are specific only to the deployment will fail after the release has been created. This can leave
* a deployment in a half finished state, so this validation ensures that the input relating to the
* deployment is valid so missing or incorrect input doesn't stop stop the deployment after a release is
* created.
*
* Note that certain validations still need to be done on the server. Permissions and lifecycle progression
* still rely on server side validation.
*/
// We might query the same tagset repeatedly, so store old queries here
var tagSetResources = new Dictionary <string, TagSetResource>();
// Make sure the tags are valid
foreach (var tenantTag in TenantTags)
{
// Verify the format of the tag
var parts = tenantTag.Split(Separator);
if (parts.Length != 2 || string.IsNullOrEmpty(parts[0]) || string.IsNullOrEmpty(parts[1]))
{
throw new CommandException(
$"Canonical Tag Name expected in the format of `TagSetName{Separator}TagName`");
}
// Query the api if the results were not previously found
if (!tagSetResources.ContainsKey(parts[0]))
{
tagSetResources.Add(parts[0], await Repository.TagSets.FindByName(parts[0]).ConfigureAwait(false));
}
// Verify the presence of the tag
if (tagSetResources[parts[0]]?.Tags?.All(tag => parts[1] != tag.Name) ?? true)
{
throw new CommandException(
$"Unable to find matching tag from canonical tag name `{tenantTag}`");
}
}
// Make sure the tenants are valid
foreach (var tenantName in Tenants)
{
if (tenantName != "*")
{
var tenant = await Repository.Tenants.FindByName(tenantName).ConfigureAwait(false);
if (tenant == null)
{
throw new CommandException(
$"Could not find the tenant {tenantName} on the Octopus Server");
}
}
}
// Make sure environment is valid
var environments = await Repository.Environments.FindByNames(DeployToEnvironmentNames).ConfigureAwait(false);
var missingEnvironment = DeployToEnvironmentNames
.Where(env => environments.All(env2 => !env2.Name.Equals(env, StringComparison.OrdinalIgnoreCase)))
.ToList();
if (missingEnvironment.Count != 0)
{
throw new CommandException(
$"The environment{(missingEnvironment.Count == 1 ? "" : "s")} {string.Join(", ", missingEnvironment)} " +
$"do{(missingEnvironment.Count == 1 ? "es" : "")} not exist or {(missingEnvironment.Count == 1 ? "is" : "are")} misspelled");
}
// Make sure the machines are valid
await GetSpecificMachines();
await base.ValidateParameters();
}
public CreateReleaseCommand(IOctopusAsyncRepositoryFactory repositoryFactory, IOctopusFileSystem fileSystem, IPackageVersionResolver versionResolver, IReleasePlanBuilder releasePlanBuilder, IOctopusClientFactory clientFactory, ICommandOutputProvider commandOutputProvider)
: base(repositoryFactory, fileSystem, clientFactory, commandOutputProvider)
{
this.releasePlanBuilder = releasePlanBuilder;
var options = Options.For("Release creation");
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("defaultpackageversion=|packageversion=", "Default version number of all packages to use for this release. Override per-package using --package.", versionResolver.Default);
options.Add("version=|releaseNumber=", "[Optional] Release number to use for the new release.", v => VersionNumber = v);
options.Add("channel=", "[Optional] Channel to use for the new release. Omit this argument to automatically select the best channel.", v => ChannelName = v);
options.Add("package=", "[Optional] Version number to use for a step or package in the release. Format: --package={StepNameOrPackageId}:{Version}", v => versionResolver.Add(v));
options.Add("packagesFolder=", "[Optional] A folder containing NuGet packages from which we should get versions.", v => { v.CheckForIllegalPathCharacters("packagesFolder"); versionResolver.AddFolder(v); });
options.Add("releasenotes=", "[Optional] Release Notes for the new release. Styling with Markdown is supported.", v => ReleaseNotes = v);
options.Add("releasenotesfile=", "[Optional] Path to a file that contains Release Notes for the new release. Supports Markdown files.", ReadReleaseNotesFromFile);
options.Add("ignoreexisting", "[Optional, Flag] Don't create this release if there is already one with the same version number.", v => IgnoreIfAlreadyExists = true);
options.Add("ignorechannelrules", "[Optional, Flag] Create the release ignoring any version rules specified by the channel.", v => IgnoreChannelRules = true);
options.Add("packageprerelease=", "[Optional] Pre-release for latest version of all packages to use for this release.", v => VersionPreReleaseTag = v);
options.Add("whatif", "[Optional, Flag] Perform a dry run but don't actually create/deploy release.", v => WhatIf = true);
options = Options.For("Deployment");
options.Add("deployto=", "[Optional] Environment to automatically deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
}
public async Task Request()
{
var serverSupportsChannels = ServerSupportsChannels();
commandOutputProvider.Debug(serverSupportsChannels ? "This Octopus Server supports channels" : "This Octopus Server does not support channels");
commandOutputProvider.Debug("Finding project: {Project:l}", ProjectName);
project = await Repository.Projects.FindByName(ProjectName).ConfigureAwait(false);
if (project == null)
{
throw new CouldNotFindException("a project named", ProjectName);
}
plan = await BuildReleasePlan(project).ConfigureAwait(false);
if (!string.IsNullOrWhiteSpace(VersionNumber))
{
versionNumber = VersionNumber;
commandOutputProvider.Debug("Using version number provided on command-line: {Version:l}", versionNumber);
}
else if (!string.IsNullOrWhiteSpace(plan.ReleaseTemplate.NextVersionIncrement))
{
versionNumber = plan.ReleaseTemplate.NextVersionIncrement;
commandOutputProvider.Debug("Using version number from release template: {Version:l}", versionNumber);
}
else if (!string.IsNullOrWhiteSpace(plan.ReleaseTemplate.VersioningPackageStepName))
{
versionNumber = plan.GetActionVersionNumber(plan.ReleaseTemplate.VersioningPackageStepName);
commandOutputProvider.Debug("Using version number from package step: {Version:l}", versionNumber);
}
else
{
throw new CommandException(
"A version number was not specified and could not be automatically selected.");
}
commandOutputProvider.Write(
plan.IsViableReleasePlan() ? LogEventLevel.Information : LogEventLevel.Warning,
"Release plan for {Project:l} {Version:l}" + System.Environment.NewLine + "{Plan:l}",
ProjectName, versionNumber, plan.FormatAsTable()
);
if (plan.HasUnresolvedSteps())
{
throw new CommandException(
"Package versions could not be resolved for one or more of the package packageSteps in this release. See the errors above for details. Either ensure the latest version of the package can be automatically resolved, or set the version to use specifically by using the --package argument.");
}
if (plan.ChannelHasAnyEnabledSteps() == false)
{
if (serverSupportsChannels)
{
throw new CommandException($"Channel {plan.Channel.Name} has no available steps");
}
else
{
throw new CommandException($"Plan has no available steps");
}
}
if (plan.HasStepsViolatingChannelVersionRules())
{
if (IgnoreChannelRules)
{
commandOutputProvider.Warning("At least one step violates the package version rules for the Channel '{Channel:l}'. Forcing the release to be created ignoring these rules...", plan.Channel.Name);
}
else
{
throw new CommandException(
$"At least one step violates the package version rules for the Channel '{plan.Channel.Name}'. Either correct the package versions for this release, let Octopus select the best channel by omitting the --channel argument, select a different channel using --channel=MyChannel argument, or ignore these version rules altogether by using the --ignoreChannelRules argument.");
}
}
if (IgnoreIfAlreadyExists)
{
commandOutputProvider.Debug("Checking for existing release for {Project:l} {Version:l} because you specified --ignoreexisting...", ProjectName, versionNumber);
try
{
var found = await Repository.Projects.GetReleaseByVersion(project, versionNumber)
.ConfigureAwait(false);
if (found != null)
{
commandOutputProvider.Information("A release of {Project:l} with the number {Version:l} already exists, and you specified --ignoreexisting, so we won't even attempt to create the release.", ProjectName, versionNumber);
return;
}
}
catch (OctopusResourceNotFoundException)
{
// Expected
commandOutputProvider.Debug("No release exists - the coast is clear!");
}
}
if (WhatIf)
{
// We were just doing a dry run - bail out here
if (DeployToEnvironmentNames.Any())
{
commandOutputProvider.Information("[WhatIf] This release would have been created using the release plan and deployed to {Environments:l}", DeployToEnvironmentNames.CommaSeperate());
}
else
{
commandOutputProvider.Information("[WhatIf] This release would have been created using the release plan");
}
}
else
{
// Actually create the release!
commandOutputProvider.Debug("Creating release...");
release = await Repository.Releases.Create(new ReleaseResource(versionNumber, project.Id, plan.Channel?.Id)
{
ReleaseNotes = ReleaseNotes,
SelectedPackages = plan.GetSelections()
}, ignoreChannelRules : IgnoreChannelRules)
.ConfigureAwait(false);
commandOutputProvider.Information("Release {Version:l} created successfully!", release.Version);
commandOutputProvider.ServiceMessage("setParameter", new { name = "octo.releaseNumber", value = release.Version });
commandOutputProvider.TfsServiceMessage(ServerBaseUrl, project, release);
await DeployRelease(project, release).ConfigureAwait(false);
}
}
public PromoteReleaseCommand(IOctopusAsyncRepositoryFactory repositoryFactory, ILogger log, IOctopusFileSystem fileSystem, IOctopusClientFactory clientFactory)
: base(repositoryFactory, log, fileSystem, clientFactory)
{
var options = Options.For("Release Promotion");
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("from=", "Name of the environment to get the current deployment from, e.g., Staging", v => FromEnvironmentName = v);
options.Add("to=|deployto=", "Environment to deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
}
public PromoteReleaseCommand(IOctopusAsyncRepositoryFactory repositoryFactory, IOctopusFileSystem fileSystem, IOctopusClientFactory clientFactory, ICommandOutputProvider commandOutputProvider)
: base(repositoryFactory, fileSystem, clientFactory, commandOutputProvider)
{
var options = Options.For("Release Promotion");
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("from=", "Name of the environment to get the current deployment from, e.g., Staging", v => FromEnvironmentName = v);
options.Add("to=|deployto=", "Environment to deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
options.Add("updateVariables", "Overwrite the variable snapshot for the release by re-importing the variables from the project", v => UpdateVariableSnapshot = true);
}
protected override void SetOptions(OptionSet options)
{
SetCommonOptions(options);
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("deployto=", "Environment to deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
options.Add("releaseNumber=|version=", "Version number of the release to deploy.", v => VersionNumber = v);
}
public DeployReleaseCommand(IOctopusAsyncRepositoryFactory repositoryFactory, IOctopusFileSystem fileSystem, IOctopusClientFactory clientFactory, ICommandOutputProvider commandOutputProvider)
: base(repositoryFactory, fileSystem, clientFactory, commandOutputProvider)
{
var options = Options.For("Deployment");
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("deployto=", "Environment to deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
options.Add("releaseNumber=|version=", "Version number of the release to deploy. Or specify --version=latest for the latest release.", v => VersionNumber = v);
options.Add("channel=", "[Optional] Channel to use when getting the release to deploy", v => ChannelName = v);
options.Add("updateVariables", "Overwrite the variable snapshot for the release by re-importing the variables from the project", v => UpdateVariableSnapshot = true);
}
protected override void SetOptions(OptionSet options)
{
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("deployto=", "Environment to deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
options.Add("releaseNumber=|version=", "Version number of the release to deploy.", v => VersionNumber = v);
options.Add("force", "Whether to force redeployment of already installed packages (flag, default false).", v => Force = true);
options.Add("forcepackagedownload", "Whether to force downloading of already installed packages (flag, default false).", v => ForcePackageDownload = true);
options.Add("waitfordeployment", "Whether to wait synchronously for deployment to finish.", v => WaitForDeployment = true);
options.Add("deploymenttimeout=", "[Optional] Specifies maximum time (timespan format) that deployment can take (default 00:10:00)", v => DeploymentTimeout = TimeSpan.Parse(v));
options.Add("deploymentchecksleepcycle=", "[Optional] Specifies how much time (timespan format) should elapse between deployment status checks (default 00:00:10)", v => DeploymentStatusCheckSleepCycle = TimeSpan.Parse(v));
}
public DeployReleaseCommand(IOctopusAsyncRepositoryFactory repositoryFactory, ILogger log, IOctopusFileSystem fileSystem, IOctopusClientFactory clientFactory)
: base(repositoryFactory, log, fileSystem, clientFactory)
{
DeploymentStatusCheckSleepCycle = TimeSpan.FromSeconds(10);
DeploymentTimeout = TimeSpan.FromMinutes(10);
var options = Options.For("Deployment");
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("deployto=", "Environment to deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
options.Add("releaseNumber=|version=", "Version number of the release to deploy. Or specify --version=latest for the latest release.", v => VersionNumber = v);
options.Add("channel=", "[Optional] Channel to use when getting the release to deploy", v => ChannelName = v);
options.Add("updateVariables", "Overwrite the variable snapshot for the release by re-importing the variables from the project", v => UpdateVariableSnapshot = true);
}
protected override void SetOptions(OptionSet options)
{
SetCommonOptions(options);
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("from=", "Name of the environment to get the current deployment from, e.g., Staging", v => FromEnvironmentName = v);
options.Add("to=|deployto=", "Environment to deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
}
protected override void Execute()
{
Log.Debug("This Octopus Server {0} channels", ServerSupportsChannels() ? "supports" : "does not support");
Log.Debug("Finding project: " + ProjectName);
var project = Repository.Projects.FindByName(ProjectName);
if (project == null)
{
throw new CouldNotFindException("a project named", ProjectName);
}
var plan = BuildReleasePlan(project);
string versionNumber;
if (!string.IsNullOrWhiteSpace(VersionNumber))
{
versionNumber = VersionNumber;
Log.Debug("Using version number provided on command-line: " + versionNumber);
}
else if (!string.IsNullOrWhiteSpace(plan.ReleaseTemplate.NextVersionIncrement))
{
versionNumber = plan.ReleaseTemplate.NextVersionIncrement;
Log.Debug("Using version number from release template: " + versionNumber);
}
else if (!string.IsNullOrWhiteSpace(plan.ReleaseTemplate.VersioningPackageStepName))
{
versionNumber = plan.GetActionVersionNumber(plan.ReleaseTemplate.VersioningPackageStepName);
Log.Debug("Using version number from package step: " + versionNumber);
}
else
{
throw new CommandException("A version number was not specified and could not be automatically selected.");
}
if (plan.IsViableReleasePlan())
{
Log.Information($"Release plan for {ProjectName} {versionNumber}{Environment.NewLine}{plan.FormatAsTable()}");
}
else
{
Log.Warning($"Release plan for {ProjectName} {versionNumber}{Environment.NewLine}{plan.FormatAsTable()}");
}
if (plan.HasUnresolvedSteps())
{
throw new CommandException("Package versions could not be resolved for one or more of the package steps in this release. See the errors above for details. Either ensure the latest version of the package can be automatically resolved, or set the version to use specifically by using the --package argument.");
}
if (plan.HasStepsViolatingChannelVersionRules())
{
if (IgnoreChannelRules)
{
Log.Warning($"At least one step violates the package version rules for the Channel '{plan.Channel.Name}'. Forcing the release to be created ignoring these rules...");
}
else
{
throw new CommandException($"At least one step violates the package version rules for the Channel '{plan.Channel.Name}'. Either correct the package versions for this release, let Octopus select the best channel by omitting the --channel argument, select a different channel using --channel=MyChannel argument, or ignore these version rules altogether by using the --ignoreChannelRules argument.");
}
}
if (IgnoreIfAlreadyExists)
{
Log.Debug($"Checking for existing release for {ProjectName} {versionNumber} because you specified --ignoreexisting...");
try
{
var found = Repository.Projects.GetReleaseByVersion(project, versionNumber);
if (found != null)
{
Log.Information($"A release of {ProjectName} with the number {versionNumber} already exists, and you specified --ignoreexisting, so we won't even attempt to create the release.");
return;
}
}
catch (OctopusResourceNotFoundException)
{
// Expected
Log.Debug("No release exists - the coast is clear!");
}
}
if (WhatIf)
{
// We were just doing a dry run - bail out here
Log.Information("[WhatIf] This release would have been created using the release plan{0}",
DeployToEnvironmentNames.Any() ? $" and deployed to {DeployToEnvironmentNames.CommaSeperate()}" : string.Empty);
}
else
{
// Actually create the release!
Log.Debug("Creating release...");
var release = Repository.Releases.Create(new ReleaseResource(versionNumber, project.Id, plan.Channel?.Id)
{
ReleaseNotes = ReleaseNotes,
SelectedPackages = plan.GetSelections()
}, ignoreChannelRules: IgnoreChannelRules);
Log.Information($"Release {release.Version} created successfully!");
Log.ServiceMessage("setParameter", new { name = "octo.releaseNumber", value = release.Version });
Log.TfsServiceMessage(ServerBaseUrl, project, release);
DeployRelease(project, release);
}
}
public CreateReleaseCommand(IOctopusRepositoryFactory repositoryFactory, ILogger log, IOctopusFileSystem fileSystem, IPackageVersionResolver versionResolver, IReleasePlanBuilder releasePlanBuilder)
: base(repositoryFactory, log, fileSystem)
{
this.releasePlanBuilder = releasePlanBuilder;
DeploymentStatusCheckSleepCycle = TimeSpan.FromSeconds(10);
DeploymentTimeout = TimeSpan.FromMinutes(10);
var options = Options.For("Release creation");
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("defaultpackageversion=|packageversion=", "Default version number of all packages to use for this release. Override per-package using --package.", versionResolver.Default);
options.Add("version=|releaseNumber=", "[Optional] Release number to use for the new release.", v => VersionNumber = v);
options.Add("channel=", "[Optional] Channel to use for the new release. Omit this argument to automatically select the best channel.", v => ChannelName = v);
options.Add("package=", "[Optional] Version number to use for a package in the release. Format: --package={StepName}:{Version}", v => versionResolver.Add(v));
options.Add("packagesFolder=", "[Optional] A folder containing NuGet packages from which we should get versions.", v => versionResolver.AddFolder(v));
options.Add("releasenotes=", "[Optional] Release Notes for the new release.", v => ReleaseNotes = v);
options.Add("releasenotesfile=", "[Optional] Path to a file that contains Release Notes for the new release.", ReadReleaseNotesFromFile);
options.Add("ignoreexisting", "[Optional, Flag] Don't create this release if there is already one with the same version number.", v => IgnoreIfAlreadyExists = true);
options.Add("ignorechannelrules", "[Optional, Flag] Create the release ignoring any version rules specified by the channel.", v => IgnoreChannelRules = true);
options.Add("packageprerelease=", "[Optional] Pre-release for latest version of all packages to use for this release.", v => VersionPreReleaseTag = v);
options.Add("whatif", "[Optional, Flag] Perform a dry run but don't actually create/deploy release.", v => WhatIf = true);
options = Options.For("Deployment");
options.Add("deployto=", "[Optional] Environment to automatically deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
}
protected override void SetOptions(OptionSet options)
{
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("deployto=", "[Optional] Environment to automatically deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
options.Add("releaseNumber=|version=", "Release number to use for the new release.", v => VersionNumber = v);
options.Add("defaultpackageversion=|packageversion=", "Default version number of all packages to use for this release.", v => versionResolver.Default(v));
options.Add("package=|packageversionoverride=", "[Optional] Version number to use for a package in the release. Format: --package={PackageId}:{Version}", v => versionResolver.Add(v));
options.Add("packagesFolder=", "[Optional] A folder containing NuGet packages from which we should get versions.", v => versionResolver.AddFolder(v));
options.Add("forceversion", "Ignored (obsolete).", v => { });
options.Add("force", "Whether to force redeployment of already installed packages (flag, default false).", v => Force = true);
options.Add("forcepackagedownload", "Whether to force downloading of already installed packages (flag, default false).", v => ForcePackageDownload = true);
options.Add("releasenotes=", "Release Notes for the new release.", v => ReleaseNotes = v);
options.Add("releasenotesfile=", "Path to a file that contains Release Notes for the new release.", ReadReleaseNotesFromFile);
options.Add("waitfordeployment", "Whether to wait synchronously for deployment to finish.", v => WaitForDeployment = true);
options.Add("deploymenttimeout=", "[Optional] Specifies maximum time (timespan format) that deployment can take (default 00:10:00)", v => DeploymentTimeout = TimeSpan.Parse(v));
options.Add("deploymentchecksleepcycle=", "[Optional] Specifies how much time (timespan format) should elapse between deployment status checks (default 00:00:10)", v => DeploymentStatusCheckSleepCycle = TimeSpan.Parse(v));
}
protected override void SetOptions(OptionSet options)
{
SetCommonOptions(options);
options.Add("project=", "Name of the project", v => ProjectName = v);
options.Add("deployto=", "[Optional] Environment to automatically deploy to, e.g., Production", v => DeployToEnvironmentNames.Add(v));
options.Add("releaseNumber=|version=", "[Optional] Release number to use for the new release.", v => VersionNumber = v);
options.Add("defaultpackageversion=|packageversion=", "Default version number of all packages to use for this release.", v => versionResolver.Default(v));
options.Add("package=", "[Optional] Version number to use for a package in the release. Format: --package={StepName}:{Version}", v => versionResolver.Add(v));
options.Add("packagesFolder=", "[Optional] A folder containing NuGet packages from which we should get versions.", v => versionResolver.AddFolder(v));
options.Add("releasenotes=", "[Optional] Release Notes for the new release.", v => ReleaseNotes = v);
options.Add("releasenotesfile=", "[Optional] Path to a file that contains Release Notes for the new release.", ReadReleaseNotesFromFile);
options.Add("ignoreexisting", "", v => IgnoreIfAlreadyExists = true);
}