public async Task CanEditAnAssetLabel()
{
var releaseWithNoUpdate = new ReleaseUpdate("0.1")
{
Draft = true
};
var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload
{
ContentType = "text/plain",
FileName = "hello-world.txt",
RawData = stream
};
var result = await _releaseClient.UploadAsset(release, newAsset);
var asset = await _releaseClient.GetAsset(_repositoryOwner, _repositoryName, result.Id);
var updateAsset = asset.ToUpdate();
updateAsset.Label = "some other thing";
var updatedAsset = await _releaseClient.EditAsset(_repositoryOwner, _repositoryName, result.Id, updateAsset);
Assert.Equal("some other thing", updatedAsset.Label);
}
public async Task CanDownloadAnAsset()
{
var releaseWithNoUpdate = new ReleaseUpdate("0.1")
{
Draft = true
};
var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload
{
ContentType = "text/plain",
FileName = "hello-world.txt",
RawData = stream
};
var result = await _releaseClient.UploadAsset(release, newAsset);
Assert.True(result.Id > 0);
var asset = await _releaseClient.GetAsset(_repositoryOwner, _repositoryName, result.Id);
Assert.Equal(result.Id, asset.Id);
var response = await _github.Connection.Get <object>(new Uri(asset.Url), new Dictionary <string, string>(), "application/octet-stream");
Assert.Equal("This is a plain text file.", response.Body);
}
public async Task <Release> UpdateRelease()
{
IReadOnlyList <Release> releases = await _releaser.Client.Repository.Release.GetAll(_releaser.Account, _releaser.Repo); // Get() throw exception if not found
Release release = releases.FirstOrDefault(obj => obj.Name.Equals(_releaser.VersionFull));
if (release == null)
{
ErrorHandler.Log("Release to update not found");
}
ReleaseUpdate updateRelease = release.ToUpdate();
updateRelease.Draft = _releaser.Settings.IsDraft;
var result = await _releaser.Client.Repository.Release.Edit(_releaser.Account, _releaser.Repo, release.Id, updateRelease);
// Attachments
if (result.Assets.Any())
{
foreach (var asset in result.Assets)
{
await _releaser.Client.Repository.Release.DeleteAsset(_releaser.Account, _releaser.Repo, asset.Id);
}
}
await UploadAttachments(result);
return(result);
}
public async Task CanUploadAndRetrieveAnAsset()
{
var releaseWithNoUpdate = new ReleaseUpdate("0.1")
{
Draft = true
};
var release = await _releaseClient.CreateRelease(_repositoryOwner, _repositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload
{
ContentType = "text/plain", FileName = "hello-world.txt", RawData = stream
};
var result = await _releaseClient.UploadAsset(release, newAsset);
Assert.True(result.Id > 0);
var assets = await _releaseClient.GetAssets(_repositoryOwner, _repositoryName, release.Id);
Assert.Equal(1, assets.Count);
var asset = assets[0];
Assert.Equal(result.Id, asset.Id);
Assert.NotNull(asset.Url);
}
private static async Task CreateRelease(GitHubClient github, string owner, string repository, string milestone, string targetCommitish, string asset)
{
var releaseNotesBuilder = new ReleaseNotesBuilder(new DefaultGitHubClient(github, owner, repository), owner, repository, milestone);
var result = await releaseNotesBuilder.BuildReleaseNotes();
var releaseUpdate = new ReleaseUpdate(milestone)
{
Draft = true,
Body = result,
Name = milestone
};
if (!string.IsNullOrEmpty(targetCommitish))
{
releaseUpdate.TargetCommitish = targetCommitish;
}
var release = await github.Release.Create(owner, repository, releaseUpdate);
if (File.Exists(asset))
{
var upload = new ReleaseAssetUpload {
FileName = Path.GetFileName(asset), ContentType = "application/octet-stream", RawData = File.Open(asset, FileMode.Open)
};
await github.Release.UploadAsset(release, upload);
}
}
public async Task Set(Release release)
{
ReleaseUpdate updateRelease = release.ToUpdate();
updateRelease.Body = await GetReleaseChangelog();
await _releaser.Client.Repository.Release.Edit(_releaser.Account, _releaser.Repo, release.Id, updateRelease);
}
/// <summary>
/// Creates a new <see cref="Release"/> for the specified repository.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#create-a-release">API documentation</a> for more information.
/// </remarks>
/// <param name="owner">The repository's owner</param>
/// <param name="name">The repository's name</param>
/// <param name="data">A description of the release to create</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
/// <returns>The created <see cref="Release"/>.</returns>
public IObservable<Release> CreateRelease(string owner, string name, ReleaseUpdate data)
{
Ensure.ArgumentNotNullOrEmptyString(owner, "owner");
Ensure.ArgumentNotNullOrEmptyString(name, "name");
Ensure.ArgumentNotNull(data, "data");
return _client.CreateRelease(owner, name, data).ToObservable();
}
/// <summary>
/// Edits an existing <see cref="Release"/> for the specified repository.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#edit-a-release">API documentation</a> for more information.
/// </remarks>
/// <param name="owner">The repository's owner</param>
/// <param name="name">The repository's name</param>
/// <param name="id">The id of the release</param>
/// <param name="data">A description of the release to edit</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
/// <returns>The updated <see cref="Release"/>.</returns>
public IObservable <Release> Edit(string owner, string name, int id, ReleaseUpdate data)
{
Ensure.ArgumentNotNullOrEmptyString(owner, "owner");
Ensure.ArgumentNotNullOrEmptyString(name, "name");
Ensure.ArgumentNotNull(data, "data");
return(_client.Edit(owner, name, id, data).ToObservable());
}
private static async Task <Release> UpdateRelease(string owner, string repoName, Release release, Action <ReleaseUpdate> updateRelease)
{
ReleaseUpdate releaseUpdate = release.ToUpdate();
updateRelease(releaseUpdate);
var updatedRelease = await client.Repository.Release.Edit(owner, repoName, release.Id, releaseUpdate);
return(updatedRelease);
}
public void RequestsTheCorrectUrl()
{
var gitHubClient = Substitute.For <IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var data = new ReleaseUpdate("fake-tag");
releasesClient.EditRelease("fake", "repo", data);
gitHubClient.Release.Received(1).EditRelease("fake", "repo", data);
}
public void RequestsTheCorrectUrl()
{
var connection = Substitute.For <IApiConnection>();
var releasesClient = new ReleasesClient(connection);
var data = new ReleaseUpdate("fake-tag");
releasesClient.EditRelease("fake", "repo", 1, data);
connection.Received().Patch <Release>(Arg.Is <Uri>(u => u.ToString() == "repos/fake/repo/releases/1"), data);
}
public void CallsIntoClient()
{
var gitHubClient = Substitute.For <IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var data = new ReleaseUpdate("fake-tag");
releasesClient.CreateRelease("fake", "repo", data);
gitHubClient.Release.Received(1).CreateRelease("fake", "repo", data);
}
public void CallsIntoClient()
{
var gitHubClient = Substitute.For<IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var data = new ReleaseUpdate("fake-tag");
releasesClient.CreateRelease("fake", "repo", data);
gitHubClient.Release.Received(1).CreateRelease("fake", "repo", data);
}
private ReleaseUpdate BuildReleaseData()
{
var release = new ReleaseUpdate(TagName);
if (ReleaseNotesFile != null)
{
release.Body = File.ReadAllText(ReleaseNotesFile);
}
return(release);
}
public void EnsuresArgumentsNotNull()
{
var releasesClient = new ObservableReleasesClient(Substitute.For <IGitHubClient>());
var data = new ReleaseUpdate("fake-tag");
Assert.Throws <ArgumentNullException>(() => new ReleaseUpdate(null));
Assert.Throws <ArgumentNullException>(() => releasesClient.CreateRelease(null, "name", data));
Assert.Throws <ArgumentNullException>(() => releasesClient.CreateRelease("owner", null, data));
Assert.Throws <ArgumentNullException>(() => releasesClient.CreateRelease("owner", "name", null));
}
public void EnsuresNonNullArguments()
{
var releasesClient = new ObservableReleasesClient(Substitute.For <IGitHubClient>());
var update = new ReleaseUpdate("tag");
Assert.Throws <ArgumentNullException>(() => releasesClient.EditRelease(null, "name", update));
Assert.Throws <ArgumentException>(() => releasesClient.EditRelease("", "name", update));
Assert.Throws <ArgumentNullException>(() => releasesClient.EditRelease("owner", null, update));
Assert.Throws <ArgumentException>(() => releasesClient.EditRelease("owner", "", update));
Assert.Throws <ArgumentNullException>(() => releasesClient.EditRelease("owner", "name", null));
}
public void RequestsCorrectUrl()
{
var gitHubClient = Substitute.For<IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var data = new ReleaseUpdate("fake-tag");
releasesClient.CreateRelease("fake", "repo", data);
gitHubClient.Connection.PostAsync<Release>(
new Uri("repos/fake/repo/releases", UriKind.Relative), data, null, null);
}
/// <summary>
/// Updates a GitHub release.
/// </summary>
/// <param name="repo">Identifies the target repository.</param>
/// <param name="release">Specifies the release being updated.</param>
/// <param name="releaseUpdate">Specifies the revisions.</param>
/// <returns>The updated release.</returns>
/// <remarks>
/// <para>
/// To update a release, you'll first need to:
/// </para>
/// <list type="number">
/// <item>
/// Obtain a <see cref="Release"/> referencing the target release returned from
/// <see cref="Create(string, string, string, string, bool, bool, string)"/>
/// or by listing or getting releases.
/// </item>
/// <item>
/// Obtain a <see cref="ReleaseUpdate"/> by calling <see cref="Release.ToUpdate"/>.
/// </item>
/// <item>
/// Make your changes to the release update.
/// </item>
/// <item>
/// Call <see cref="Update(string, Release, ReleaseUpdate)"/>, passing the
/// original release along with the update.
/// </item>
/// </list>
/// </remarks>
public Release Update(string repo, Release release, ReleaseUpdate releaseUpdate)
{
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(repo), nameof(repo));
Covenant.Requires <ArgumentNullException>(release != null, nameof(release));
Covenant.Requires <ArgumentNullException>(releaseUpdate != null, nameof(releaseUpdate));
var repoPath = GitHubRepoPath.Parse(repo);
var client = GitHub.CreateGitHubClient(repo);
return(client.Repository.Release.Edit(repoPath.Owner, repoPath.Repo, release.Id, releaseUpdate).Result);
}
public async Task ReturnsReleasesWithNullPublishDate()
{
// create a release without a publish date
var releaseWithNoUpdate = new ReleaseUpdate("0.1") { Draft = true };
var release = _releaseClient.CreateRelease(_repositoryOwner, _repositoryName, releaseWithNoUpdate).Result;
var releases = await _releaseClient.GetAll(_repositoryOwner, _repositoryName);
Assert.True(releases.Count == 1);
Assert.False(releases.First().PublishedAt.HasValue);
}
private static async Task UpdateRelease(this IGitHubClient gitHubClient, Release existingRelease, string version)
{
var releaseUpdate = new ReleaseUpdate {
Name = version, TagName = version, Prerelease = IsPreRelease(version)
};
Console.WriteLine($"Renaming GitHub release '{existingRelease.Name}' to {releaseUpdate.Name}...");
var updatedRelease = await gitHubClient.Repository.Release.Edit(RepoOwner, repoName, existingRelease.Id, releaseUpdate);
Console.WriteLine($"Renamed GitHub release '{existingRelease.Name}' to {updatedRelease.Name}");
}
public void RequestsCorrectUrl()
{
var client = Substitute.For<IApiConnection>();
var releasesClient = new ReleasesClient(client);
var data = new ReleaseUpdate("fake-tag");
releasesClient.Create("fake", "repo", data);
client.Received().Post<Release>(Arg.Is<Uri>(u => u.ToString() == "repos/fake/repo/releases"),
data,
"application/vnd.github.v3");
}
public void RequestsCorrectUrl()
{
var client = Substitute.For <IApiConnection>();
var releasesClient = new ReleasesClient(client);
var data = new ReleaseUpdate("fake-tag");
releasesClient.CreateRelease("fake", "repo", data);
client.Received().Post <Release>(Arg.Is <Uri>(u => u.ToString() == "repos/fake/repo/releases"),
data,
"application/vnd.github.v3");
}
public void RequestsTheCorrectUrlWithRepositoryId()
{
var gitHubClient = Substitute.For <IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var data = new ReleaseUpdate {
TagName = "fake-tag"
};
releasesClient.Edit(1, 1, data);
gitHubClient.Repository.Release.Received(1).Edit(1, 1, data);
}
public async Task EnsuresArgumentsNotNull()
{
var releasesClient = new ReleasesClient(Substitute.For<IApiConnection>());
var data = new ReleaseUpdate("fake-tag");
Assert.Throws<ArgumentNullException>(() => new ReleaseUpdate(null));
await AssertEx.Throws<ArgumentNullException>(async () =>
await releasesClient.Create(null, "name", data));
await AssertEx.Throws<ArgumentNullException>(async () =>
await releasesClient.Create("owner", null, data));
await AssertEx.Throws<ArgumentNullException>(async () =>
await releasesClient.Create("owner", "name", null));
}
public async Task RequestsTheCorrectUrlWithRepositoryId()
{
var connection = Substitute.For <IApiConnection>();
var releasesClient = new ReleasesClient(connection);
var data = new ReleaseUpdate {
TagName = "fake-tag"
};
await releasesClient.Edit(1, 1, data);
connection.Received().Patch <Release>(Arg.Is <Uri>(u => u.ToString() == "repositories/1/releases/1"), data);
}
public void EnsuresNonNullArguments()
{
var releasesClient = new ReleasesClient(Substitute.For <IApiConnection>());
var releaseUpdate = new ReleaseUpdate {
TagName = "tag"
};
Assert.Throws <ArgumentNullException>(() => releasesClient.Edit(null, "name", 1, releaseUpdate));
Assert.Throws <ArgumentException>(() => releasesClient.Edit("", "name", 1, releaseUpdate));
Assert.Throws <ArgumentNullException>(() => releasesClient.Edit("owner", null, 1, releaseUpdate));
Assert.Throws <ArgumentException>(() => releasesClient.Edit("owner", "", 1, releaseUpdate));
Assert.Throws <ArgumentNullException>(() => releasesClient.Edit("owner", "name", 1, null));
}
public async Task <Release> UpdateReleaseAsync(int id, ReleaseUpdate updatedRelease)
{
try
{
return(await _gitHubClient.Repository.Release
.Edit(_repository.Owner, _repository.Name, id, updatedRelease)
.ConfigureAwait(false));
}
catch (NotFoundException)
{
throw new ArgumentException($"Could not find release with ID '{id}'", nameof(id));
}
}
public async Task ReturnsReleasesWithNullPublishDate()
{
// create a release without a publish date
var releaseWithNoUpdate = new ReleaseUpdate("0.1")
{
Draft = true
};
var release = _releaseClient.CreateRelease(_repositoryOwner, _repositoryName, releaseWithNoUpdate).Result;
var releases = await _releaseClient.GetAll(_repositoryOwner, _repositoryName);
Assert.True(releases.Count == 1);
Assert.False(releases.First().PublishedAt.HasValue);
}
public async Task <Release> UpdateReleaseAsync(string tagName, ReleaseUpdate updatedRelease)
{
try
{
var release = await GetReleaseAsync(tagName).ConfigureAwait(false);
return(await UpdateReleaseAsync(release.Id, updatedRelease).ConfigureAwait(false));
}
catch (NotFoundException)
{
throw new ArgumentException(
$"Could not find release with tag '{tagName}'", nameof(tagName));
}
}
public async Task EnsuresArgumentsNotNull()
{
var releasesClient = new ReleasesClient(Substitute.For <IApiConnection>());
var data = new ReleaseUpdate("fake-tag");
Assert.Throws <ArgumentNullException>(() => new ReleaseUpdate(null));
await AssertEx.Throws <ArgumentNullException>(async() =>
await releasesClient.CreateRelease(null, "name", data));
await AssertEx.Throws <ArgumentNullException>(async() =>
await releasesClient.CreateRelease("owner", null, data));
await AssertEx.Throws <ArgumentNullException>(async() =>
await releasesClient.CreateRelease("owner", "name", null));
}
private static async Task PublishRelease(GitHubClient github, string owner, string repository, string tagName)
{
var releases = await github.Repository.Release.GetAll(owner, repository);
var release = releases.FirstOrDefault(r => r.TagName == tagName);
if (release == null)
{
return;
}
var releaseUpdate = new ReleaseUpdate {
TagName = tagName, Draft = false
};
await github.Repository.Release.Edit(owner, repository, release.Id, releaseUpdate);
}
public async Task PublishRelease(string owner, string repository, string tagName)
{
var release = await GetReleaseFromTagNameAsync(owner, repository, tagName).ConfigureAwait(false);
if (release is null)
{
_logger.Verbose("No release with tag '{TagName}' was found on '{Owner}/{Repository}'", tagName, owner, repository);
return;
}
var releaseUpdate = new ReleaseUpdate {
TagName = tagName, Draft = false
};
_logger.Verbose("Publishing release '{TagName}' on '{Owner}/{Repository}'", tagName, owner, repository);
_logger.Debug("{@ReleaseUpdate}", releaseUpdate);
await _gitHubClient.Repository.Release.Edit(owner, repository, release.Id, releaseUpdate).ConfigureAwait(false);
}
public async Task CanChangeBodyOfRelease()
{
var releaseWithNoUpdate = new ReleaseUpdate("0.1")
{
Draft = true
};
var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate);
var editRelease = release.ToUpdate();
editRelease.Body = "**This is an updated release";
editRelease.Draft = false;
var updatedRelease = await _releaseClient.Edit(_repositoryOwner, _repositoryName, release.Id, editRelease);
Assert.Equal(release.Id, updatedRelease.Id);
Assert.False(updatedRelease.Draft);
Assert.Equal("**This is an updated release", updatedRelease.Body);
}
public async Task CanChangeCommitIshOfRelease()
{
var releaseWithNoUpdate = new ReleaseUpdate("0.1")
{
Draft = true
};
var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate);
Assert.Equal("master", release.TargetCommitish);
var newHead = await github.CreateTheWorld(_repository);
var editRelease = release.ToUpdate();
editRelease.Draft = false;
editRelease.TargetCommitish = newHead.Object.Sha;
var updatedRelease = await _releaseClient.Edit(_repositoryOwner, _repositoryName, release.Id, editRelease);
Assert.Equal(release.Id, updatedRelease.Id);
Assert.False(updatedRelease.Draft);
Assert.Equal(newHead.Object.Sha, updatedRelease.TargetCommitish);
}
public void EnsuresNonNullArguments()
{
var releasesClient = new ObservableReleasesClient(Substitute.For<IGitHubClient>());
var update = new ReleaseUpdate { TagName = "tag" };
Assert.Throws<ArgumentNullException>(() => releasesClient.Edit(null, "name", 1, update));
Assert.Throws<ArgumentException>(() => releasesClient.Edit("", "name", 1, update));
Assert.Throws<ArgumentNullException>(() => releasesClient.Edit("owner", null, 1, update));
Assert.Throws<ArgumentException>(() => releasesClient.Edit("owner", "", 1, update));
Assert.Throws<ArgumentNullException>(() => releasesClient.Edit("owner", "name", 1, null));
}
public void RequestsTheCorrectUrl()
{
var gitHubClient = Substitute.For<IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var data = new ReleaseUpdate { TagName = "fake-tag" };
releasesClient.Edit("fake", "repo", 1, data);
gitHubClient.Repository.Release.Received(1).Edit("fake", "repo", 1, data);
}
public async Task EnsuresNonNullArguments()
{
var releasesClient = new ReleasesClient(Substitute.For<IApiConnection>());
var releaseUpdate = new ReleaseUpdate { TagName = "tag" };
await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.Edit(null, "name", 1, releaseUpdate));
await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.Edit("owner", null, 1, releaseUpdate));
await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.Edit("owner", "name", 1, null));
await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.Edit(1, 1, null));
await Assert.ThrowsAsync<ArgumentException>(() => releasesClient.Edit("", "name", 1, releaseUpdate));
await Assert.ThrowsAsync<ArgumentException>(() => releasesClient.Edit("owner", "", 1, releaseUpdate));
}
public async Task RequestsTheCorrectUrlWithRepositoryId()
{
var connection = Substitute.For<IApiConnection>();
var releasesClient = new ReleasesClient(connection);
var data = new ReleaseUpdate { TagName = "fake-tag" };
await releasesClient.Edit(1, 1, data);
connection.Received().Patch<Release>(Arg.Is<Uri>(u => u.ToString() == "repositories/1/releases/1"), data);
}
public void RequestsTheCorrectUrl()
{
var connection = Substitute.For<IApiConnection>();
var releasesClient = new ReleasesClient(connection);
var data = new ReleaseUpdate { TagName = "fake-tag" };
releasesClient.Edit("fake", "repo", 1, data);
connection.Received().Patch<Release>(Arg.Is<Uri>(u => u.ToString() == "repos/fake/repo/releases/1"), data);
}
/// <summary>
/// Edits an existing <see cref="Release"/> for the specified repository.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#edit-a-release">API documentation</a> for more information.
/// </remarks>
/// <param name="repositoryId">The Id of the repository</param>
/// <param name="id">The id of the release</param>
/// <param name="data">A description of the release to edit</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
public IObservable <Release> Edit(long repositoryId, int id, ReleaseUpdate data)
{
Ensure.ArgumentNotNull(data, "data");
return(_client.Edit(repositoryId, id, data).ToObservable());
}
public async Task <int> Run(string[] args)
{
bool showHelp = false;
var _ = string.Empty;
string githubApiToken = null;
string nugetApiToken = null;
var options = new OptionSet
{
"kalk release app",
_,
"Usage: krel [options]",
_,
"## Options",
_,
{ "h|help", "Show this message and exit", (bool v) => showHelp = v },
{ "g|github=", "GitHub Api Token", v => githubApiToken = v },
{ "n|nuget=", "NuGet Api Token", v => nugetApiToken = v },
};
options.OptionWidth = 40;
options.LineWidth = 100;
options.ShiftNewLine = 0;
try
{
var arguments = options.Parse(args);
if (showHelp)
{
options.WriteOptionDescriptions(Console.Out);
return(0);
}
if (githubApiToken == null)
{
throw new OptionException("Missing GitHub Api Token", "github");
}
if (nugetApiToken == null)
{
throw new OptionException("Missing NuGet Api Token", "nuget");
}
}
catch (OptionException exception)
{
var backColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
await Console.Out.WriteLineAsync($"{exception.Message}. Option --{exception.OptionName}");
Console.ForegroundColor = backColor;
await Console.Out.WriteLineAsync("See --help for usage");
Environment.ExitCode = 1;
return(Environment.ExitCode);
}
var packageInfo = LoadPackageInfo();
var version = LoadVersion();
packageInfo.Version = version;
var changelog = await LoadChangeLog(version);
// Make sure that release folder is deleted before building/packaging
if (Directory.Exists(_baseConsoleNet5ReleaseFolder))
{
Directory.Delete(_baseConsoleNet5ReleaseFolder, true);
}
// Create the build folder
if (!Directory.Exists(_buildFolder))
{
Directory.CreateDirectory(_buildFolder);
}
else
{
// TODO: option to force cleanup?
}
// Build NuGet
BuildNuGet(packageInfo);
// Build Appx
BuildAppx(packageInfo);
// Build all archives
var win64Zip = PackPlatform("win-x64", version, PackageKind.Zip);
var linux64DebAndRpm = PackPlatform("linux-x64", version, PackageKind.Deb, PackageKind.Rpm);
var macOSTarGz = PackPlatform("osx-x64", version, PackageKind.TarBall);
var entries = win64Zip.Concat(linux64DebAndRpm).Concat(macOSTarGz).ToList();
Info("Connecting to GitHub");
var github = new GitHubClient(new ProductHeaderValue("krel"));
var tokenAuth = new Credentials(githubApiToken); // NOTE: not real token
github.Credentials = tokenAuth;
var releases = await github.Repository.Release.GetAll(_user, _repo);
var release = releases.FirstOrDefault(releaseCheck => releaseCheck.TagName == version) ??
await github.Repository.Release.Create(_user, _repo, new NewRelease(version));
Info($"Loading release tag {release.TagName}");
ReleaseUpdate releaseUpdate = null;
if (release.Body != changelog)
{
releaseUpdate = release.ToUpdate();
releaseUpdate.Body = changelog;
}
// Update the body if necessary
if (releaseUpdate != null)
{
Info($"Updating release {release.TagName} with new changelog");
release = await github.Repository.Release.Edit(_user, _repo, release.Id, releaseUpdate);
}
var assets = await github.Repository.Release.GetAllAssets(_user, _repo, release.Id, ApiOptions.None);
foreach (var entry in entries)
{
var filename = Path.GetFileName(entry.Path);
if (assets.Any(x => x.Name == filename))
{
Info($"No need to update {entry.Path} on GitHub. Already uploaded.");
continue;
}
const int maxHttpRetry = 10;
for (int i = 0; i < maxHttpRetry; i++)
{
try
{
Info($"{(i > 0 ? $"Retry ({{i}}/{maxHttpRetry-1}) ":"")}Uploading {filename} to GitHub Release: {version} (Size: {new FileInfo(entry.Path).Length / (1024 * 1024)}MB)");
// Upload assets
using (var stream = File.OpenRead(entry.Path))
{
await github.Repository.Release.UploadAsset(release, new ReleaseAssetUpload(filename, entry.Mime, stream, new TimeSpan(0, 5, 0)));
}
break;
}
catch (Exception ex)
{
// In case of a failure to upload try to delete the asset
try
{
assets = await github.Repository.Release.GetAllAssets(_user, _repo, release.Id, ApiOptions.None);
var assetToDelete = assets.FirstOrDefault(x => x.Name == filename);
await github.Repository.Release.DeleteAsset(_user, _repo, assetToDelete.Id);
// Refresh the list of the assets
assets = await github.Repository.Release.GetAllAssets(_user, _repo, release.Id, ApiOptions.None);
}
catch
{
Error($"Failure to delete the remote asset: {filename}");
// ignored
}
if (i + 1 == maxHttpRetry)
{
Error($"Upload failed: {ex} after {maxHttpRetry} retries.");
}
else
{
const int millisecondsDelay = 100;
Warning($"Upload failed: {ex.Message}. Retrying after {millisecondsDelay}ms...");
await Task.Delay(millisecondsDelay);
}
}
}
}
// Update homebrew
await UploadBrewFormula(github, macOSTarGz[0], packageInfo);
// Publish NuGet - last
PublishNuGet(packageInfo, nugetApiToken);
// Update Website version
await UpdateDocumentationVersion(github, packageInfo);
Environment.ExitCode = _hasErrors ? 1 : 0;
return(Environment.ExitCode);
}
public void EnsuresArgumentsNotNull()
{
var releasesClient = new ObservableReleasesClient(Substitute.For<IGitHubClient>());
var data = new ReleaseUpdate("fake-tag");
Assert.Throws<ArgumentNullException>(() => new ReleaseUpdate(null));
Assert.Throws<ArgumentNullException>(() => releasesClient.CreateRelease(null, "name", data));
Assert.Throws<ArgumentNullException>(() => releasesClient.CreateRelease("owner", null, data));
Assert.Throws<ArgumentNullException>(() => releasesClient.CreateRelease("owner", "name", null));
}
/// <summary>
/// Edits an existing <see cref="Release"/> for the specified repository.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#edit-a-release">API documentation</a> for more information.
/// </remarks>
/// <param name="repositoryId">The repository's ID</param>
/// <param name="id">The id of the release</param>
/// <param name="data">A description of the release to edit</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
public IObservable<Release> Edit(int repositoryId, int id, ReleaseUpdate data)
{
Ensure.ArgumentNotNull(data, "data");
return _client.Edit(repositoryId, id, data).ToObservable();
}
public IObservable<Release> CreateRelease(string owner, string name, ReleaseUpdate data)
{
return _client.CreateRelease(owner, name, data).ToObservable();
}
