mirrors/dotnet-installer
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Enable ability to write a fake package name with version to dotnet/versions

Browse source
This commit is contained in:
Christopher Costa 2018-08-10 13:33:53 -07:00
parent 25209c88f6
commit 74e619e704
4 changed files with 181 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
build/Microsoft.DotNet.Cli.tasks
View file

@ -31,7 +31,7 @@
<UsingTask TaskName="SetEnvVar" AssemblyFile="$(CLIBuildDll)" />
<UsingTask TaskName="TarGzFileCreateFromDirectory" AssemblyFile="$(CLIBuildDll)" />
<UsingTask TaskName="TarGzFileExtractToDirectory" AssemblyFile="$(CLIBuildDll)" />
<UsingTask TaskName="UpdateVersionsRepo" AssemblyFile="$(CLIBuildDll)"/>
<UsingTask TaskName="WriteVersionToVersionsRepo" AssemblyFile="$(CLIBuildDll)"/>
<UsingTask TaskName="UploadToAzure" AssemblyFile="$(CLIBuildDll)"/>
<UsingTask TaskName="UploadToLinuxPackageRepository" AssemblyFile="$(CLIBuildDll)"/>
<UsingTask TaskName="ZipFileCreateFromDirectory" AssemblyFile="$(CLIBuildDll)"/>

14
build/publish/FinishBuild.targets
View file

@ -32,10 +32,14 @@
Channel="$(Channel)"
CommitHash="$(CommitHash)"
Coherent="$(Coherent)" />
<UpdateVersionsRepo BranchName="$(BranchName)"
PackagesDirectory="$(PackagesDirectory)"
GitHubPassword="$(GITHUB_PASSWORD)"
Condition=" '$(GITHUB_PASSWORD)' != '' " />
<!-- Core-Sdk does not produce a core-sdk package that can be used to signal on
dotnet/versions that a new core-sdk version is available. Instead,
just publish the latest version and list a "core-sdk" package with version -->
<WriteVersionToVersionsRepo BranchName="$(BranchName)"
Name="core-sdk"
Version="$(FullNugetVersion"
GitHubPassword="$(GITHUB_PASSWORD)"
Condition=" '$(GITHUB_PASSWORD)' != '' " />
</Target>
</Project>

38
build_projects/dotnet-cli-build/UpdateVersionsRepo.cs
View file

@ -1,38 +0,0 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
#if !SOURCE_BUILD
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
using Microsoft.DotNet.VersionTools.Automation;
using System.IO;
namespace Microsoft.DotNet.Cli.Build
{
public class UpdateVersionsRepo : Task
{
[Required]
public string BranchName { get; set; }
[Required]
public string PackagesDirectory { get; set; }
[Required]
public string GitHubPassword { get; set; }
public override bool Execute()
{
string versionsRepoPath = $"build-info/dotnet/core-sdk/{BranchName}";
GitHubAuth auth = new GitHubAuth(GitHubPassword);
GitHubVersionsRepoUpdater repoUpdater = new GitHubVersionsRepoUpdater(auth);
repoUpdater.UpdateBuildInfoAsync(
Directory.GetFiles(PackagesDirectory, "*.nupkg"),
versionsRepoPath).Wait();
return true;
}
}
}
#endif

171
build_projects/dotnet-cli-build/WriteVersionToVersionsRepo.cs Normal file
View file

@ -0,0 +1,171 @@
// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
#if !SOURCE_BUILD
using Microsoft.Build.Framework;
using MSBuildUtilities = Microsoft.Build.Utilities;
using Microsoft.DotNet.VersionTools.Automation;
using Microsoft.DotNet.VersionTools.Automation.GitHubApi;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using ThreadingTasks= System.Threading.Tasks;
namespace Microsoft.DotNet.Cli.Build
{
public class WriteVersionToVersionsRepo : MSBuildUtilities.Task
{
[Required]
public string BranchName { get; set; }
[Required]
public string Name { get; set; }
[Required]
public string Version { get; set; }
[Required]
public string GitHubPassword { get; set; }
public string VersionsRepoPath { get; set; }
public override bool Execute()
{
string versionsRepoPath = VersionsRepoPath ?? $"build-info/dotnet/core-sdk/{BranchName}";
GitHubAuth auth = new GitHubAuth(GitHubPassword);
GitHubWriteVersionUpdater repoUpdater = new GitHubWriteVersionUpdater(auth);
repoUpdater.UpdateBuildInfoAsync(
Name,
Version,
versionsRepoPath).Wait();
return true;
}
}
// This code is a slightly modified port of GitHubVersionsRepoUpdater from
// https://raw.githubusercontent.com/dotnet/buildtools/master/src/Microsoft.DotNet.VersionTools/Automation/GitHubVersionsRepoUpdater.cs
internal class GitHubWriteVersionUpdater: VersionsRepoUpdater
{
private const int MaxTries = 10;
private const int RetryMillisecondsDelay = 5000;
private GitHubAuth _gitHubAuth;
private GitHubProject _project;
public GitHubWriteVersionUpdater(
GitHubAuth gitHubAuth,
string versionsRepoOwner = null,
string versionsRepo = null)
: this(
gitHubAuth,
new GitHubProject(versionsRepo ?? "versions", versionsRepoOwner))
{
}
public GitHubWriteVersionUpdater(GitHubAuth gitHubAuth, GitHubProject project)
{
if (gitHubAuth == null)
{
throw new ArgumentNullException(nameof(gitHubAuth));
}
_gitHubAuth = gitHubAuth;
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
_project = project;
}
/// <param name="updateLatestVersion">If true, updates Latest.txt with a prerelease moniker. If there isn't one, makes the file empty.</param>
/// <param name="updateLatestPackageList">If true, updates Latest_Packages.txt.</param>
public async ThreadingTasks.Task UpdateBuildInfoAsync(
string versionIdentifier,
string version,
string versionsRepoPath,
bool updateLatestPackageList = true,
bool updateLatestVersion = true)
{
if (versionIdentifier == null)
{
throw new ArgumentNullException(nameof(versionIdentifier));
}
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if (versionsRepoPath == null)
{
throw new ArgumentNullException(nameof(versionsRepoPath));
}
using (GitHubClient client = new GitHubClient(_gitHubAuth))
{
for (int i = 0; i < MaxTries; i++)
{
try
{
// Master commit to use as new commit's parent.
string masterRef = "heads/master";
GitReference currentMaster = await client.GetReferenceAsync(_project, masterRef);
string masterSha = currentMaster.Object.Sha;
List<GitObject> objects = new List<GitObject>();
if (updateLatestVersion)
{
objects.Add(new GitObject
{
Path = $"{versionsRepoPath}/Latest.txt",
Type = GitObject.TypeBlob,
Mode = GitObject.ModeFile,
Content = version
});
}
if (updateLatestPackageList)
{
objects.Add(new GitObject
{
Path = $"{versionsRepoPath}/Latest_Packages.txt",
Type = GitObject.TypeBlob,
Mode = GitObject.ModeFile,
Content = $"{versionIdentifier} {version}{Environment.NewLine}"
});
}
string message = $"Updating {versionsRepoPath}";
GitTree tree = await client.PostTreeAsync(_project, masterSha, objects.ToArray());
GitCommit commit = await client.PostCommitAsync(_project, message, tree.Sha, new[] { masterSha });
// Only fast-forward. Don't overwrite other changes: throw exception instead.
await client.PatchReferenceAsync(_project, masterRef, commit.Sha, force: false);
Trace.TraceInformation($"Committed build-info update on attempt {i + 1}.");
break;
}
catch (HttpRequestException ex)
{
int nextTry = i + 1;
if (nextTry < MaxTries)
{
Trace.TraceInformation($"Encountered exception committing build-info update: {ex.Message}");
Trace.TraceInformation($"Trying again in {RetryMillisecondsDelay}ms. {MaxTries - nextTry} tries left.");
await ThreadingTasks.Task.Delay(RetryMillisecondsDelay);
}
else
{
Trace.TraceInformation("Encountered exception committing build-info update.");
throw;
}
}
}
}
}
}
}
#endif