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