public static bool HasPartiallySucceededTasks(this ReleaseEnvironment source) { IList <ReleaseTask> tasks = GetReleaseTasks(source); return(!tasks.Any() || tasks.Any(task => task.Status == TaskStatus.PartiallySucceeded)); }
public System.IO.Stream GetReleaseTaskAttachmentContent() { string projectName = ClientSampleHelpers.FindAnyProject(this.Context).Name; // Get a release client instance VssConnection connection = Context.Connection; ReleaseHttpClient releaseClient = connection.GetClient <ReleaseHttpClient>(); WebApiRelease release = releaseClient.GetReleaseAsync(project: projectName, releaseId: this._newlyCreatedRelease).Result; // Get release task attachments ReleaseEnvironment environment = release.Environments.FirstOrDefault(); DeploymentAttempt deployStep = environment.DeploySteps.First(); Guid planId = deployStep.ReleaseDeployPhases.First().RunPlanId.Value; List <ReleaseTaskAttachment> releaseTaskAttachment = releaseClient.GetReleaseTaskAttachmentsAsync(project: projectName, releaseId: release.Id, environmentId: environment.Id, attemptId: deployStep.Attempt, planId: planId, type: "myattachmenttype").Result; ReleaseTaskAttachment firstReleaseTaskAttachment = releaseTaskAttachment.First(); Guid timelineId = firstReleaseTaskAttachment.TimelineId; Guid recordId = firstReleaseTaskAttachment.RecordId; string attachmentType = firstReleaseTaskAttachment.Type; string attachmentName = firstReleaseTaskAttachment.Name; System.IO.Stream attachmentData = releaseClient.GetReleaseTaskAttachmentContentAsync(project: projectName, releaseId: release.Id, environmentId: environment.Id, attemptId: deployStep.Attempt, planId: planId, timelineId: timelineId, recordId: recordId, type: attachmentType, name: attachmentName).Result; Context.Log("{0} {1}", attachmentName.PadLeft(6), attachmentType); return(attachmentData); }
private SolutionDeploy.Core.DeploymentStatus DoGetReleaseEnvironmentStatus(int releaseId, int environmentId) { Release release = this.releaseClient.GetRelease(releaseId, this.accessToken); if (release == null) { return(SolutionDeploy.Core.DeploymentStatus.Unknown); } ReleaseEnvironment releaseEnvironment = release.Environments.FirstOrDefault(e => e.Id == environmentId); if (releaseEnvironment == null) { return(SolutionDeploy.Core.DeploymentStatus.Unknown); } EnvironmentStatus environmentStatus = releaseEnvironment.Status; if (environmentStatus == EnvironmentStatus.InProgress) { return(this.CheckForPendingApprovals(releaseId)); } return(GetDeploymentStatus(environmentStatus)); }
private async Task <List <PhaseData> > GetPhasesAsync(ReleaseEnvironment environment) { var phases = new List <PhaseData>(); int index = 0; foreach (var releasePhase in environment.GetPhases()) { var name = "Run on Agent"; if (environment.DeployPhasesSnapshot.ElementAtOrDefault(index) != null) { name = environment.DeployPhasesSnapshot[index].Name; } var phase = new PhaseData { Name = name, Rank = releasePhase.Rank, Status = releasePhase.Status.ToString(), Jobs = releasePhase.DeploymentJobs .Select(job => new JobData { JobStatus = job.Job.Status, JobName = job.Job.Name, Issues = job.Job.Issues.Select(issue => new IssueData { IssueType = issue.IssueType, Message = issue.Message, }).ToList(), Tasks = job .Tasks .Select(item => new TaskData { AgentName = item.AgentName, Name = item.Name, StartTime = item.StartTime, FinishTime = item.FinishTime, Status = item.Status, Issues = item.Issues .Select(issue => new IssueData { IssueType = issue.IssueType, Message = issue.Message, }) .ToList(), }) .ToList() }) .ToList() }; phases.Add(phase); index++; } return(await Task.FromResult(phases)); }
private ReleaseEnvironment GetTestEnvironment(EnvironmentStatus status) { ReleaseEnvironment releaseEnvironment = new ReleaseEnvironment { Status = status }; return(releaseEnvironment); }
public static List <ReleaseDeployPhase> GetPhases(this ReleaseEnvironment source) { List <ReleaseDeployPhase> phases = new List <ReleaseDeployPhase>(); if (source?.DeploySteps != null && source.DeploySteps.Any()) { DeploymentAttempt deploymentAttempt = source.GetMaxDeploymentAttempt(); foreach (var releaseDeployPhase in deploymentAttempt.ReleaseDeployPhases) { phases.Add(releaseDeployPhase); } } return(phases); }
public void TestDeployDemoNoAzureOk() { // Arrange var postBody = new PostBody { id = "someguid", instance = "some-dyn-instance", username = "******", password = "******", email = "*****@*****.**", resetInstance = false, }; var environment = new ReleaseEnvironment(); TestDeployDemo(postBody, environment); }
private async Task <Release> GetReleaseByLastCompletedEnvironmentAsync(ReleaseEnvironment environment) { string artifactAlias = null; string branchId = null; if (_release.Artifacts.Any()) { var primaryArtifact = _release.Artifacts.FirstOrDefault(artifact => artifact.IsPrimary); if (primaryArtifact != null) { artifactAlias = primaryArtifact.Alias; branchId = primaryArtifact.GetArtifactInfo(Microsoft.VisualStudio.Services.ReleaseManagement.WebApi.ArtifactDefinitionConstants.BranchId)?.Id; } } _logger.LogInformation( $"Fetching last release by completed environment id - {_releaseConfiguration.EnvironmentId}" + $" with artifact alias - {artifactAlias} & branch id {branchId}"); // TODO - retry var releases = //RetryHelper.Retry(() => await _releaseHttpClient.GetReleasesAsync(_releaseConfiguration.ProjectId, _release.ReleaseDefinitionReference.Id, environment.DefinitionEnvironmentId, (int)EnvironmentStatus.Succeeded | (int)EnvironmentStatus.PartiallySucceeded | (int)EnvironmentStatus.Rejected | (int)EnvironmentStatus.Canceled, ReleaseQueryOrder.Descending, 1, ReleaseExpands.Environments, artifactAlias, branchId) ?? new List <Release>(); var lastRelease = releases.FirstOrDefault(); if (lastRelease == null) { _logger.LogInformation( $"Unable to find any release with completed environment for environment id - {_releaseConfiguration.EnvironmentId}"); } else { // Fetch more details on the last completed release i.e. AggregatedAnalysis of test outcomes // TODO - Retry return //RetryHelper.Retry(() => (await _releaseHttpClient.GetReleaseAsync(_releaseConfiguration.ProjectId, lastRelease.Id)); } return(lastRelease); }
public static List <ReleaseTask> GetReleaseTasks(this ReleaseEnvironment source) { List <ReleaseTask> tasks = new List <ReleaseTask>(); if (source?.DeploySteps != null && source.DeploySteps.Any()) { DeploymentAttempt deploymentAttempt = source.GetMaxDeploymentAttempt(); foreach (var releaseDeployPhase in deploymentAttempt.ReleaseDeployPhases) { foreach (var deploymentJob in releaseDeployPhase.DeploymentJobs) { tasks.AddRange(deploymentJob.Tasks); } } } return(tasks); }
private string DoGetReleaseEnvironmentId( int releaseId, string environmentName) { Release release = this.releaseClient.GetRelease(releaseId, this.accessToken); if (release == null) { return(null); } ReleaseEnvironment environment = release.Environments .FirstOrDefault(e => e.Name.Equals(environmentName, StringComparison.InvariantCultureIgnoreCase)); if (environment == null) { return(null); } return(environment.Id.ToString()); }
public void UpdateReleaseEnvironment_Succeeds() { VstsConfig vstsConfig = GetVstsConfig(); IHttpClient httpClient = new HttpClient(); ITokenRepository repository = new JsonFileTokenRepository(new FileSystem()); IAuthenticator authenticator = new VstsOAuthAuthenticator(httpClient, repository, vstsConfig); File.Copy($"..//..//..//testdata//{TokenFilename}", fullTokenFilename, true); AuthenticationResult authResult = authenticator.Authenticate(); File.Copy(fullTokenFilename, $"..//..//..//testdata//{TokenFilename}", true); this.sut = new VstsSyncReleaseClient(vstsConfig); ReleaseEnvironment result = this.sut.UpdateReleaseEnvironment(11, 11, authResult.AccessToken); Assert.NotNull(result); Assert.Equal(EnvironmentStatus.Queued, result.Status); }
private async Task <ReleaseEnvironment> GetEnvironmentAsync() { ReleaseEnvironment environment = _release.Environments.FirstOrDefault(env => env.Id == _releaseConfiguration.EnvironmentId); if (_releaseConfiguration.UsePreviousEnvironment) { if (_release.Environments.IndexOf(environment) - 1 < 0) { throw new EmailReportException( $"Unable to find previous environment for given environment id - {_releaseConfiguration.EnvironmentId} in release - {_release.Id}"); } environment = _release.Environments[_release.Environments.IndexOf(environment) - 1]; } if (environment != null) { return(await Task.FromResult(environment)); } throw new EmailReportException( $"Unable to find environment with environment id - {_releaseConfiguration.EnvironmentId} in release - {_release.Id}"); }
public ReleaseViewModel(ReleaseEnvironment currentEnvironment, ReleaseConfiguration releaseConfig) { if (currentEnvironment != null) { CurrentEnvironment = new ReleaseEnvironmentViewModel(currentEnvironment); ReleaseDefinitionName = currentEnvironment.ReleaseDefinitionReference ?.Name; if (currentEnvironment.ReleaseDefinitionReference != null) { ReleaseDefinitionUrl = LinkHelper.GetReleaseDefinitionLink(releaseConfig, currentEnvironment.ReleaseDefinitionReference.Id); } ReleaseName = currentEnvironment.ReleaseReference?.Name; } ReleaseId = releaseConfig.Id; ReleaseSummaryUrl = LinkHelper.GetReleaseSummaryLink(releaseConfig); ReleaseLogsLink = LinkHelper.GetReleaseLogsTabLink(releaseConfig); }
public void TestDeployAzureWithAzureOk() { // Arrange var postBody = new PostBody { id = "1ba2fb0e-cca7-46c3-b926-7828f224a406", instance = "some-dyn-instance", username = "******", password = "******", email = "*****@*****.**", resetInstance = false, }; var environment = new ReleaseEnvironment(); environment.Variables.Add("azUniqueName", new ConfigurationVariableValue()); environment.Variables.Add("azResourceGroup", new ConfigurationVariableValue()); TestDeployDemo(postBody, environment); Assert.AreEqual(environment.Variables["azUniqueName"].Value, "somedyninstance"); Assert.AreEqual(environment.Variables["azResourceGroup"].Value, "dd-somedyninstance-rg"); }
public System.IO.Stream GetLogsOfReleaseTask() { string projectName = ClientSampleHelpers.FindAnyProject(this.Context).Name; // Get a release client instance VssConnection connection = Context.Connection; ReleaseHttpClient releaseClient = connection.GetClient <ReleaseHttpClient>(); // Get Release Defintion ReleaseDefinition releaseDefinition = releaseClient.GetReleaseDefinitionAsync(project: projectName, definitionId: newlyCreatedReleaseDefinitionId).Result; // Get all completed environment releases. // environmentStatusFilter values Undefined = 0, NotStarted = 1, InProgress = 2, Succeeded = 4, Canceled = 8, Rejected = 16, Qeued = 32, Scheduled = 64, PartiallySucceeded = 128 List <WebApiRelease> releases = new List <WebApiRelease>(); ClientSampleHelpers.Retry( TimeSpan.FromMinutes(2), TimeSpan.FromSeconds(5), () => { releases = releaseClient.GetReleasesAsync(project: projectName, definitionId: releaseDefinition.Id, definitionEnvironmentId: releaseDefinition.Environments.First().Id, expand: ReleaseExpands.Environments, environmentStatusFilter: 4).Result; return(releases.Count > 0); }); // Get first release first environment first deployment first task log WebApiRelease release = releaseClient.GetReleaseAsync(project: projectName, releaseId: releases.First().Id).Result; this.completedReleaseId = release.Id; ReleaseEnvironment releaseEnvironment = release.Environments.First(); ReleaseDeployPhase deployPhase = releaseEnvironment.DeploySteps.First().ReleaseDeployPhases.FirstOrDefault(); ReleaseTask task = deployPhase.DeploymentJobs.First().Tasks.First(); System.IO.Stream taskLog = releaseClient.GetTaskLogAsync(project: projectName, releaseId: release.Id, environmentId: releaseEnvironment.Id, releaseDeployPhaseId: deployPhase.Id, taskId: task.Id).Result; Context.Log("{0} {1}", release.Id.ToString().PadLeft(6), release.Id); return(taskLog); }
public WebApiRelease StartDeployment() { string projectName = ClientSampleHelpers.FindAnyProject(this.Context).Name; // Get a release client instance VssConnection connection = Context.Connection; ReleaseHttpClient releaseClient = connection.GetClient <ReleaseHttpClient>(); WebApiRelease release = CreateRelease(releaseClient, newlyCreatedReleaseDefinitionId, projectName); ReleaseEnvironmentUpdateMetadata releaseEnvironmentUpdateMetadata = new ReleaseEnvironmentUpdateMetadata() { Status = EnvironmentStatus.InProgress }; int releaseEnvironmentId = release.Environments.FirstOrDefault().Id; // Start deployment to an environment ReleaseEnvironment releaseEnvironment = releaseClient.UpdateReleaseEnvironmentAsync(releaseEnvironmentUpdateMetadata, projectName, release.Id, releaseEnvironmentId).Result; Console.WriteLine("{0} {1}", releaseEnvironment.Id.ToString().PadLeft(6), releaseEnvironment.Name); return(release); }
public List <ReleaseTaskAttachment> GetReleaseAttachment() { string projectName = ClientSampleHelpers.FindAnyProject(this.Context).Name; ReleaseDefinition definition = new ReleaseDefinition() { Name = releaseDefinitionName, Revision = 1, Environments = new List <ReleaseDefinitionEnvironment>() { new ReleaseDefinitionEnvironment() { Name = "PROD", Conditions = new List <Condition>() { new Condition() { ConditionType = ConditionType.Event, Name = "ReleaseStarted" } }, DeployPhases = new List <DeployPhase>() { new AgentBasedDeployPhase() { Name = "Run on agent", Rank = 1, DeploymentInput = new AgentDeploymentInput() { QueueId = 1 }, WorkflowTasks = new List <WorkflowTask> { new WorkflowTask { Name = taskName, Enabled = true, TimeoutInMinutes = 0, Inputs = new Dictionary <string, string> { { "targetType", "inline" }, { "script", "New-Item -Path 'newfile.txt' -ItemType File\n\nWrite-Host \"##vso[task.addattachment type=myattachmenttype;name=myattachmentname;]$(SYSTEM.DEFAULTWORKINGDIRECTORY)\\newfile.txt\"" } }, TaskId = new Guid("e213ff0f-5d5c-4791-802d-52ea3e7be1f1"), Version = "2.*", DefinitionType = "task", Condition = "succeeded()", } } } }, PreDeployApprovals = new ReleaseDefinitionApprovals() { Approvals = new List <ReleaseDefinitionApprovalStep>() { new ReleaseDefinitionApprovalStep() { IsAutomated = true, Rank = 1 } } }, PostDeployApprovals = new ReleaseDefinitionApprovals() { Approvals = new List <ReleaseDefinitionApprovalStep>() { new ReleaseDefinitionApprovalStep() { IsAutomated = true, Rank = 1 } } }, RetentionPolicy = new EnvironmentRetentionPolicy() { DaysToKeep = 30, ReleasesToKeep = 3, RetainBuild = true } } } }; // Get a release client instance VssConnection connection = Context.Connection; ReleaseHttpClient releaseClient = connection.GetClient <ReleaseHttpClient>(); // create a release definition ReleaseDefinition releaseDefinition = releaseClient.CreateReleaseDefinitionAsync(project: projectName, releaseDefinition: definition).Result; this._newlyCreatedReleaseDefinitionId = releaseDefinition.Id; Context.Log("{0} {1} {2}", releaseDefinition.Id.ToString().PadLeft(6), releaseDefinition.Name, projectName); // create a release WebApiRelease release = ReleasesSample.CreateRelease(releaseClient, _newlyCreatedReleaseDefinitionId, projectName); Context.Log("{0} {1}", release.Id.ToString().PadLeft(6), release.Name); _newlyCreatedRelease = release.Id; // Wait till deployment completed ClientSampleHelpers.Retry( TimeSpan.FromMinutes(2), TimeSpan.FromSeconds(5), () => { release = releaseClient.GetReleaseAsync(project: projectName, releaseId: release.Id).Result; return(release != null && release.Environments.First().Status == EnvironmentStatus.Succeeded); }); // Get release task attachments ReleaseEnvironment environment = release.Environments.FirstOrDefault(); DeploymentAttempt deployStep = environment.DeploySteps.First(); Guid planId = deployStep.ReleaseDeployPhases.First().RunPlanId.Value; List <ReleaseTaskAttachment> releaseTaskAttachment = releaseClient.GetReleaseTaskAttachmentsAsync(project: projectName, releaseId: release.Id, environmentId: environment.Id, attemptId: deployStep.Attempt, planId: planId, type: "myattachmenttype").Result; Context.Log("{0} {1}", releaseTaskAttachment.First().Name.PadLeft(6), releaseTaskAttachment.First().Type); return(releaseTaskAttachment); }
public static DeploymentAttempt GetMaxDeploymentAttempt(this ReleaseEnvironment source) { return(source.DeploySteps.TakeMax(step => step.Attempt)); }
public async Task <List <DisplayEnvironment> > GetEnvironmentsAsync() { var client = VssClientHelper.GetClient <ReleaseHttpClient>( Settings.GlobalSettings.Current.AccountUrl, Settings.GlobalSettings.Current.ApiKey, Settings.GlobalSettings.Current.UseSsl); var environments = new List <DisplayEnvironment>(); List <ReleaseDefinition> definitions = await client.GetReleaseDefinitionsAsync(Settings.GlobalSettings.Current.Project, expand : ReleaseDefinitionExpands.Environments); string[] environmentNames = definitions.SelectMany(d => d.Environments).Select(e => e.Name).Distinct().ToArray(); List <Release> releases = await client.GetReleasesAsync( Settings.GlobalSettings.Current.Project, expand : ReleaseExpands.Environments, // Reduce number of releases to load faster minCreatedTime : DateTime.Today.AddMonths(-6)); foreach (string environmentName in environmentNames) { var environment = new DisplayEnvironment { Name = environmentName }; foreach (ReleaseDefinition definition in definitions) { ReleaseDefinitionEnvironment definitionEnvironment = definition.Environments.FirstOrDefault(e => e.Name == environmentName); if (definitionEnvironment == null) { continue; } Release[] definitionReleases = releases .Where(r => r.ReleaseDefinitionReference.Id == definition.Id && r.Environments.Any(e => e.Name == environmentName)) .OrderBy(r => r.CreatedOn) .ToArray(); Release lastSuccess = definitionReleases.LastOrDefault(r => r.Environments.First(e => e.Name == environmentName).Status == EnvironmentStatus.Succeeded); Release last = definitionReleases.LastOrDefault(); ReleaseEnvironment releaseEnvironment = last?.Environments.First(e => e.Name == environmentName); environment.Releases.Add(new DisplayRelease { Id = last?.Id ?? 0, DefinitionId = definition.Id, EnvironmentId = releaseEnvironment?.Id, Name = definition.Name, AvailableVersion = last != null ? Regex.Match(last.Name, Settings.GlobalSettings.Current.ReleaseNameExtractVersionRegex).Value : null, AvailableVersionLink = (last?.Links.Links["web"] as ReferenceLink)?.Href, LastDeployedVersion = lastSuccess != null ? Regex.Match(lastSuccess.Name, Settings.GlobalSettings.Current.ReleaseNameExtractVersionRegex).Value : String.Empty, LastDeployedVersionLink = (lastSuccess?.Links.Links["web"] as ReferenceLink)?.Href, Status = (DisplayReleaseStatus?)releaseEnvironment?.Status }); } environments.Add(environment); } return(environments); }
public void TestDeployDemo(PostBody postBody, ReleaseEnvironment environment) { var(fakeRequest, fakeLog) = SetupPost(postBody); Environment.SetEnvironmentVariable("VstsUrl", "https://someaccount.visualstudio.com", EnvironmentVariableTarget.Process); var releaseDefinitions = JsonConvert.DeserializeObject <List <ReleaseDefinition> >( File.ReadAllText("GetReleaseDefinitionsResult.json") ); var fakeReleaseHttpClientTestableWrapper = A.Fake <ReleaseHttpClientTestableWrapper>(); A.CallTo(() => fakeReleaseHttpClientTestableWrapper.GetReleaseDefinitions(null, null)).WithAnyArguments() .Returns(releaseDefinitions); var release = new Release(); release.Environments.Add(environment); environment.Variables.Add("dynDomain", new ConfigurationVariableValue()); environment.Variables.Add("dynUser", new ConfigurationVariableValue()); environment.Variables.Add("dynPassword", new ConfigurationVariableValue()); environment.Variables.Add("dynTenant", new ConfigurationVariableValue()); environment.Variables.Add("emailNotificationAddress", new ConfigurationVariableValue()); environment.Variables.Add("resetInstance", new ConfigurationVariableValue()); A.CallTo(() => fakeReleaseHttpClientTestableWrapper.CreateRelease(null, null, null)).WithAnyArguments() .Returns(release); A.CallTo(() => fakeReleaseHttpClientTestableWrapper.UpdateRelease(null, null, 0, null)).WithAnyArguments() .Returns(release); A.CallTo(() => fakeReleaseHttpClientTestableWrapper.UpdateReleaseResource(null, null, 0, null)).WithAnyArguments() .Returns(release); var fakeReleaseHttpClient = A.Fake <ReleaseHttpClient>(x => x.WithArgumentsForConstructor(() => new ReleaseHttpClient(Settings.VstsUri, Settings.VstsCredential))); // Act var response = DeployDemo.TestableRun(fakeRequest, fakeLog, fakeReleaseHttpClientTestableWrapper, fakeReleaseHttpClient).Result; // Assert Assert.IsInstanceOfType(response, typeof(HttpResponseMessage)); //var result = (OkObjectResult)response; var jsonString = response.Content.ReadAsStringAsync().Result; dynamic r = JsonConvert.DeserializeObject <JObject>(jsonString); //dynamic r = (JObject)result.Value; Assert.AreEqual((string)r.status, "success"); Assert.AreEqual(environment.Variables["dynDomain"].Value, postBody.instance); Assert.AreEqual(environment.Variables["dynUser"].Value, "some"); Assert.AreEqual(environment.Variables["dynPassword"].Value, postBody.password); Assert.AreEqual(environment.Variables["dynTenant"].Value, "user.com"); Assert.AreEqual(environment.Variables["emailNotificationAddress"].Value, postBody.email); Assert.AreEqual(environment.Variables["resetInstance"].Value, postBody.resetInstance.ToString()); }
public static ReleaseTask GetFailedTask(this ReleaseEnvironment source) { IList <ReleaseTask> tasks = GetReleaseTasks(source); return(tasks.FirstOrDefault(task => task.Status == TaskStatus.Failed)); }
public ReleaseEnvironmentViewModel(ReleaseEnvironment environment) { EnvironmentName = environment?.Name; EnvironmentOwnerEmail = environment?.Owner?.UniqueName; }