async Task ImportVstsReleasesDataAsync(ReleaseManagement releaseManagement, string branch, ReleaseDefinitionId releaseDefinitionId)
{
Console.WriteLine($"Import VSTS releases from branch [{branch}] started at {DateTime.UtcNow}.");
SqlConnection sqlConnection = null;
try
{
sqlConnection = new SqlConnection(this.dbConnectionString);
sqlConnection.Open();
List <IoTEdgeRelease> releaseResults = await releaseManagement.GetReleasesAsync(releaseDefinitionId, branch, 200);
Console.WriteLine($"Query VSTS releases for branch [{branch}] and release definition [{releaseDefinitionId.ToString()}]: result count={releaseResults.Count} at {DateTime.UtcNow}.");
int releaseCount = 0;
foreach (IoTEdgeRelease release in releaseResults.Where(r => r.HasResult()))
{
UpsertVstsReleaseToDb(sqlConnection, release);
foreach (KeyValuePair <int, string> kvp in ReleaseEnvironment.DefinitionIdToDisplayNameMapping)
{
IoTEdgeReleaseEnvironment releaseEnvironment = release.GetEnvironment(kvp.Key);
if (releaseEnvironment.HasResult())
{
UpsertVstsReleaseEnvironmentToDb(sqlConnection, release.Id, releaseEnvironment, kvp.Value);
foreach (IoTEdgeReleaseDeployment deployment in releaseEnvironment.Deployments)
{
UpsertVstsReleaseDeploymentToDb(sqlConnection, releaseEnvironment.Id, deployment);
const string testTaskPrefix = "Test:";
foreach (IoTEdgePipelineTask pipelineTask in deployment.Tasks.Where(x => IsTestTask(x, testTaskPrefix)))
{
UpsertVstsReleaseTaskToDb(sqlConnection, deployment.Id, pipelineTask, testTaskPrefix);
}
}
}
}
releaseCount++;
if (releaseCount % 10 == 0)
{
Console.WriteLine($"Query VSTS releases for branch [{branch}] and release definition [{releaseDefinitionId.ToString()}]: release count={releaseCount} at {DateTime.UtcNow}.");
}
}
}
catch (Exception)
{
throw;
}
finally
{
sqlConnection?.Close();
}
}
public async Task RunAsync(TimeSpan waitPeriodAfterEachUpdate, CancellationToken ct)
{
var buildManagement = new BuildManagement(devOpsAccessSetting);
var releaseManagement = new ReleaseManagement(devOpsAccessSetting);
var bugManagement = new BugManagement(devOpsAccessSetting);
while (!ct.IsCancellationRequested)
{
await ImportVstsBugDataAsync(bugManagement, bugQueries);
foreach (string branch in this.branches)
{
buildLastUpdatePerBranchPerDefinition.Upsert(
branch,
await ImportVstsBuildsDataAsync(buildManagement, branch, BuildExtension.BuildDefinitions));
}
foreach (string branch in this.branches)
{
await ImportVstsReleasesDataAsync(releaseManagement, branch, ReleaseDefinitionId.E2ETest);
}
Console.WriteLine($"Import Vsts data finished at {DateTime.UtcNow}; wait {waitPeriodAfterEachUpdate} for next update.");
await Task.Delay((int)waitPeriodAfterEachUpdate.TotalMilliseconds);
}
}
public async Task ReconcileIntegrationTest()
{
var client = new VstsRestClient(_config.Organization, _config.Token);
var projectId = (await client.GetAsync(Project.Properties(_config.Project))).Id;
var releasePipeline = await client.GetAsync(ReleaseManagement.Definition(_config.Project, "1"))
.ConfigureAwait(false);
await ManagePermissions
.ForReleasePipeline(client, projectId, releasePipeline.Id, releasePipeline.Path)
.Permissions(Release.DeleteReleasePipelines)
.SetToAsync(PermissionId.Allow);
var rule = new NobodyCanDeleteReleases(client);
(await rule.EvaluateAsync(projectId, releasePipeline))
.ShouldBe(false);
await rule.ReconcileAsync(projectId, releasePipeline.Id);
await Policy
.Handle <Exception>()
.WaitAndRetryAsync(Constants.NumRetries, t => TimeSpan.FromSeconds(t))
.ExecuteAsync(async() =>
{
(await rule.EvaluateAsync(projectId, releasePipeline)).ShouldBe(true);
});
}
public async Task RunAsync(TimeSpan waitPeriodAfterEachUpdate, CancellationToken ct)
{
var buildManagement = new BuildManagement(devOpsAccessSetting);
var releaseManagement = new ReleaseManagement(devOpsAccessSetting);
var bugWiqlManagement = new BugWiqlManagement(devOpsAccessSetting);
var bugManagement = new BugManagement(devOpsAccessSetting);
while (!ct.IsCancellationRequested)
{
await ImportVstsBugDataAsync(bugWiqlManagement, bugQueries);
foreach (string branch in this.branches)
{
foreach (BuildDefinitionId buildDefinitionId in BuildExtension.BuildDefinitions)
{
IList <VstsBuild> builds = await GetBuildsAndTrackLastUpdatedAsync(buildManagement, buildDefinitionId, branch);
Console.WriteLine($"Received {builds.Count} builds");
ImportVstsBuildsDataForSpecificDefinitionAsync(builds, buildDefinitionId);
await OpenBugsForFailingBuilds(bugManagement, builds, branch, buildDefinitionId);
}
}
foreach (string branch in this.branches)
{
await ImportVstsReleasesDataAsync(releaseManagement, branch, ReleaseDefinitionId.E2ETest);
}
Console.WriteLine($"Import Vsts data finished at {DateTime.UtcNow}; wait {waitPeriodAfterEachUpdate} for next update.");
await Task.Delay((int)waitPeriodAfterEachUpdate.TotalMilliseconds);
}
}
public async Task EvaluateIntegrationTest()
{
//Arrange
var client = new VstsRestClient(_config.Organization, _config.Token);
var releasePipeline = await client.GetAsync(ReleaseManagement.Definition(_config.Project, PipelineId))
.ConfigureAwait(false);
//Act
var rule = new PipelineHasRequiredRetentionPolicy(client);
var result = await rule.EvaluateAsync(_config.Project, releasePipeline);
//Assert
result.ShouldBe(true);
}
public async Task ReconcileAsync(string projectId, string itemId)
{
if (projectId == null)
{
throw new ArgumentNullException(nameof(projectId));
}
if (itemId == null)
{
throw new ArgumentNullException(nameof(itemId));
}
var releasePipeline = await _client.GetAsync(ReleaseManagement.Definition(projectId, itemId))
.ConfigureAwait(false);
await Permissions(projectId, itemId, releasePipeline.Path)
.SetToAsync(PermissionId.Deny)
.ConfigureAwait(false);
}
async Task ImportVstsReleasesDataAsync(ReleaseManagement releaseManagement, string branch, ReleaseDefinitionId releaseDefinitionId)
{
SqlConnection sqlConnection = null;
try
{
sqlConnection = new SqlConnection(this.dbConnectionString);
sqlConnection.Open();
List <IoTEdgeRelease> releaseResults = await releaseManagement.GetReleasesAsync(releaseDefinitionId, branch, 200);
Console.WriteLine($"Query VSTS for branch [{branch}] and release definition [{releaseDefinitionId.ToString()}]: result count={releaseResults.Count}");
foreach (IoTEdgeRelease release in releaseResults.Where(r => r.HasResult()))
{
UpsertVstsReleaseToDb(sqlConnection, release);
foreach (KeyValuePair <int, string> kvp in ReleaseEnvironment.DefinitionIdToDisplayNameMapping)
{
IoTEdgeReleaseEnvironment releaseEnvironment = release.GetEnvironment(kvp.Key);
if (releaseEnvironment.HasResult())
{
UpsertVstsReleaseEnvironmentToDb(sqlConnection, release.Id, releaseEnvironment, kvp.Value);
}
}
}
}
catch (Exception)
{
throw;
}
finally
{
sqlConnection?.Close();
}
}
static async Task Main(string[] args)
{
var devOpsAccessSetting = new DevOpsAccessSetting("<PAT>");
try
{
var releaseManagement = new ReleaseManagement(devOpsAccessSetting);
List <IoTEdgeRelease> releases = await releaseManagement.GetReleasesAsync(ReleaseDefinitionId.E2ETest, "refs/heads/master");
var agentManagement = new AgentManagement(devOpsAccessSetting);
IList <VstsAgent> agents = await agentManagement.GetAgentsAsync(AgentManagement.IoTEdgeAgentPoolId).ConfigureAwait(false);
var agentMatrix = new AgentMatrix();
agentMatrix.Update(agents.Select(IoTEdgeAgent.Create).ToHashSet());
var unmatchedAgents = agentMatrix.GetUnmatchedAgents();
var buildManagement = new BuildManagement(devOpsAccessSetting);
var result = await buildManagement.GetLatestBuildsAsync(BuildExtension.MasterBranchReporting, "refs/heads/master").ConfigureAwait(false);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public void Setup()
{
this.httpTest = new HttpTest();
this.releaseManagement = new ReleaseManagement(new DevOpsAccessSetting(PersonalAccessToken));
}
public async Task CheckForCredentialsAndOtherSecrets()
{
var settings = await _client.GetAsync(ReleaseManagement.Settings(_project));
settings.ComplianceSettings.CheckForCredentialsAndOtherSecrets.ShouldBeTrue();
}
