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