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); }