public DeploymentResource GetDeployment(string environmentName, string releaseVersion = null)
{
var env = WebClient.GetWebClientRef().GetEnvironmentByName(environmentName);
var release = releaseVersion is null ? null : GetReleaseByVersion(releaseVersion);
return(GetDeployment(env, release));
}
/// <summary>
/// Deploy every project in a project group. It will promote releases of every project in the input group with
/// given source Env to Target Env. By default, the deployment will start immediately, skip the projects are
/// disabled and doesn't have the deployment at the input env and follow the alphabetical order of projects'
/// name.
/// The mandatory vars in settings are SourceEnvironmentName and TargetEnvironmentName
/// </summary>
/// <param name="groupName">The project group needed to be pushed</param>
/// <param name="settings">Use GroupDeploymentSettings to pass special requirement. i.e. queue time</param>
/// <returns>a list of the deploymentRecourse</returns>
/// <exception cref="DeploymentSettingsMissingException">If one of Env name is missing</exception>
public static List <DeploymentResource> PromoteProjectGroup(string groupName, GroupPromotingSettings
settings)
{
var group = WebClient.GetWebClientRef().GetGroupByName(groupName);
var projects = WebClient.GetWebClientRef().GetOctopusRepository().ProjectGroups.GetProjects(group);
var deployments = new List <DeploymentResource>();
if (settings.SourceEnvironmentName == null || settings.TargetEnvironmentName == null)
{
throw new DeploymentSettingsMissingException("Please make sure both envs name are set up");
}
if (settings.SpecificProjectsToInclude.Length == 0)
{
foreach (var project in projects)
{
var projectName = project.Name;
if (!settings.ProjectsToExclude.Contains(projectName))
{
deployments.Add(Deployments.PromoteRelease(projectName, settings));
}
}
}
else
{
foreach (var projectName in settings.SpecificProjectsToInclude)
{
deployments.Add(Deployments.PromoteRelease(projectName, settings));
}
}
return(deployments);
}
public OctoTask(string taskId)
{
var taskRepo = WebClient.GetWebClientRef().GetTaskRepo();
Task = taskRepo.Get(taskId);
TaskDetails = taskRepo.GetDetails(Task);
}
public void ReRun()
{
var taskRepo = WebClient.GetWebClientRef().GetOctopusRepository().Tasks;
taskRepo.Rerun(Task);
Task = taskRepo.Refresh(Task);
PrintCurrentState();
}
public TaskState GetResultState()
{
var taskRepo = WebClient.GetWebClientRef().GetOctopusRepository().Tasks;
taskRepo.WaitForCompletion(Task);
Task = taskRepo.Refresh(Task);
return(Task.State);
}
public static DeploymentResource PromoteRelease(string projectName, string releaseVersion,
SingleReleasePromotingSettings settings)
{
var project = new OctoProject(projectName);
var sourceEnv = WebClient.GetWebClientRef().GetEnvironmentByName(settings.SourceEnvironmentName);
settings.Release = releaseVersion is null ? null : project.GetReleaseByVersion(releaseVersion);
return(PromoteRelease(project, sourceEnv, settings));
}
public static OctoMachines GetMachinesByMachineName(List <string> machineNames)
{
List <MachineResource> res = new List <MachineResource>();
foreach (var machineName in machineNames)
{
res.Add(WebClient.GetWebClientRef().GetMachineByName(machineName));
}
return(new OctoMachines(res));
}
public OctoTask ExecuteScripts(string scriptBody, string description = null, string syntaxType = "PowerShell")
{
var repo = WebClient.GetWebClientRef().GetTaskRepo();
description = description ?? $"Run Scripts against {string.Join(", ", NameList.Take(4).ToArray())}";
var task = new OctoTask(repo.ExecuteAdHocScript(scriptBody, IdList.ToArray(), null, null, description, syntaxType));
task.PrintCurrentState();
return(task);
}
/// <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)));
}
public OctoTask CheckConnectivityToMachines(string description = null)
{
var repo = WebClient.GetWebClientRef().GetTaskRepo();
description = description ?? $"Check Connectivity to {string.Join(", ", NameList.Take(4).ToArray())}";
var timeOutAfterMinutes = int.Parse(ConfigurationManager.AppSettings["TimeOutAfterMinutes"]);
var machineTimeoutAfterMinutes = int.Parse(ConfigurationManager.AppSettings["MachineTimeoutAfterMinutes"]);
var task = new OctoTask(repo.ExecuteHealthCheck(description, timeOutAfterMinutes, machineTimeoutAfterMinutes,
null,
IdList.ToArray()));
task.PrintCurrentState();
return(task);
}
public List <string> GetTargetRolesNameList()
{
var l = new List <string>();
var process = WebClient.GetWebClientRef().GetDeploymentProcessRepo().Get(GetDeploymentProcessId());
var steps = process.Steps;
foreach (var s in steps)
{
if (!s.Properties.ContainsKey("Octopus.Action.TargetRoles"))
{
continue;
}
var role = s.Properties["Octopus.Action.TargetRoles"].Value;
if (!l.Contains(role) || role == null)
{
l.Add(role);
}
}
return(l);
}
public void PrintCurrentState(bool waitForCompletion = true)
{
var startTime = Task.StartTime ?? DateTimeOffset.Now;
var taskRepo = WebClient.GetWebClientRef().GetOctopusRepository().Tasks;
var webPageLink = ConfigurationManager.AppSettings["OctoBaseUrl"] + Task.Link("Web");
Console.WriteLine($"{Task.Name} Will Start at {startTime}");
Console.WriteLine($"Task Link: {webPageLink}");
if (!waitForCompletion)
{
Console.WriteLine("Not Wait for Completion, Start Next Task");
Console.WriteLine("----------------------------------------");
return;
}
;
taskRepo.WaitForCompletion(Task);
Task = taskRepo.Refresh(Task);
var endTime = DateTimeOffset.Now;
switch (Task.State)
{
case TaskState.Success:
Console.WriteLine("Task is finished successfully at {0}, taking {1}", endTime.LocalDateTime,
endTime - startTime);
break;
case TaskState.Failed:
Console.WriteLine("Task failed at {0}, taking {1}", endTime.LocalDateTime,
endTime - startTime);
Console.WriteLine(Task.ErrorMessage);
break;
case TaskState.Canceled:
Console.WriteLine("Task got canceled at {0}, taking {1}", endTime.LocalDateTime,
endTime - startTime);
break;
}
Console.WriteLine("----------------------------------------");
}
public static OctoMachines GetMachinesByEnvName(string environmentName, List <string> roles = null)
{
var env = WebClient.GetWebClientRef().GetEnvironmentByName(environmentName);
var machines = WebClient.GetWebClientRef().GetEnvironmentRepo().GetMachines(env);
List <MachineResource> res = new List <MachineResource>();
if (roles == null)
{
res = machines;
}
else
{
foreach (var machine in machines)
{
if (machine.Roles.Overlaps(roles))
{
res.Add(machine);
}
}
}
return(new OctoMachines(res));
}
public ChannelResource GetChannelByName(string channelName)
{
var repo = WebClient.GetWebClientRef().GetOctopusRepository();
return(repo.Channels.FindByName(Curr, channelName));
}
public IList <DeploymentResource> GetAllDeployment(ReleaseResource release)
{
return(WebClient.GetWebClientRef().GetOctopusRepository().Releases
.GetDeployments(release).Items);
}
public IReadOnlyList <ReleaseResource> GetAllReleases()
{
return(WebClient.GetWebClientRef().GetOctopusRepository().Projects.GetAllReleases(Curr));
}
public OctoProject(string projectName)
{
Curr = WebClient.GetWebClientRef().GetProjectByName(projectName);
ProjectName = Curr.Name;
}
public static DeploymentResource CreateDeployment(OctoProject project, ReleaseResource release,
SingleProjectDeploymentSettings settings)
{
var client = WebClient.GetWebClientRef();
// Check if the project has been disabled
if (project.IsDisabled() || settings.Force || release == null)
{
return(null);
}
Console.WriteLine($"Starting to Create Deployment for {project.ProjectName}");
// Update the variable set
if (settings.UpdateVariableSetNow)
{
Console.WriteLine($"Update Release {release.Version} variables now");
release = client.GetReleaseRepo().SnapshotVariables(release);
}
if (settings.NeedRebootAfterDeployment)
{
Console.WriteLine("Deployment Target Server(s) Will Reboot After Deployment");
settings.WaitingForFinish = true;
}
//creating the deployment object
var deployment = new DeploymentResource
{
ReleaseId = release.Id,
ProjectId = project.GetProjectId(),
EnvironmentId = client.GetEnvironmentIdByName(settings.TargetEnvironmentName),
SpecificMachineIds = settings.ConvertMachineNames(),
Comments = settings.Comments,
UseGuidedFailure = settings.UseGuidedFailure,
SkipActions = settings.ConvertSkipSteps()
};
// Schedule the deployment if deployment time is greater than now
if (settings.DeployAt > DateTime.Now)
{
deployment.QueueTime = new DateTimeOffset(settings.DeployAt);
settings.WaitingForFinish = false;
}
deployment = client.GetDeploymentRepo().Create(deployment);
Console.WriteLine($"{project.ProjectName} will {deployment.Name}");
var task = new OctoTask(deployment);
task.PrintCurrentState(settings.WaitingForFinish);
if (!settings.NeedRebootAfterDeployment)
{
return(deployment);
}
var rolesNameList = project.GetTargetRolesNameList();
var machines = OctoMachines.GetMachinesByEnvName(settings.TargetEnvironmentName, rolesNameList);
machines.RestartServer();
return(deployment);
}
public static ReleaseResource CreateRelease(string projectName, CreateReleaseSettings settings)
{
var client = WebClient.GetWebClientRef();
var project = new OctoProject(projectName);
var targetChannel = project.GetChannelByName(settings.ReleaseChannel);
var process = client.GetDeploymentProcessRepo().Get(project.GetDeploymentProcessId());
var template = client.GetDeploymentProcessRepo().GetTemplate(process, targetChannel);
if (project.IsDisabled() && !settings.IgnoreChannelRules)
{
return(null);
}
// If no version set up in the createReleaseSettings, Create a version number by using template
if (string.IsNullOrEmpty(settings.ReleaseVersion))
{
settings.ReleaseVersion = template.NextVersionIncrement;
}
// Initialize the new release with basic settings
var newRelease = new ReleaseResource {
ProjectId = project.GetProjectId(),
ChannelId = targetChannel.Id,
Version = settings.ReleaseVersion,
ReleaseNotes = settings.ReleaseNotes
};
Console.WriteLine("Create Release Version: {0} of {1} at {2}", settings.ReleaseVersion, projectName, targetChannel.Name);
var feedRepo = client.GetFeedRepo();
// Select packages
foreach (var package in template.Packages)
{
var actionName = package.ActionName;
var packageId = package.PackageId;
var feedId = package.FeedId;
var selectedPackage = new SelectedPackage()
{
ActionName = actionName
};
// If the package version is not specify, choose the one with the latest version at the current channel
if (settings.Packages is null)
{
var feed = feedRepo.Get(feedId);
var latestPackageVersion = feedRepo.GetVersions(feed, new[] { packageId }).FirstOrDefault();
// When the package needed doesn't exist on Octopus repo
if (latestPackageVersion is null)
{
throw new PackageNotFoundException(
$"Please upload package: {packageId} to Octopus repo");
}
selectedPackage.Version = latestPackageVersion.Version;
}
else
{
selectedPackage.Version = settings.Packages[package.PackageId];
}
Console.WriteLine("{0}: {1} {2}", actionName, packageId, selectedPackage.Version);
newRelease.SelectedPackages.Add(selectedPackage);
}
return(client.GetReleaseRepo().Create(newRelease, settings.IgnoreChannelRules));
}
public OctoTask(DeploymentResource deployment)
{
Task = WebClient.GetWebClientRef().GetOctopusRepository().Tasks.Get(deployment.TaskId);
}
