private static async Task AddAssets(GitHubClient github, IList <string> assets, Release release)
{
if (assets != null)
{
foreach (var asset in assets)
{
if (!File.Exists(asset))
{
continue;
}
var upload = new ReleaseAssetUpload
{
FileName = Path.GetFileName(asset),
ContentType = "application/octet-stream",
RawData = File.Open(asset, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
};
await github.Repository.Release.UploadAsset(release, upload);
// Make sure to tidy up the stream that was created above
upload.RawData.Dispose();
}
}
}
public static async Task Upload()
{
var rls = await Client.Repository.Release.Get(owner : Owner, name : Repo, tag : $"v{_stringVersion}{_experimental}");
if (rls.Assets.Any(x => x.Name == ZipName))
{
Logger.WriteLine("ERROR: This release already contains an asset with the same name.");
return;
}
var str = new MemoryStream();
var bytes = File.ReadAllBytes(Path.Combine(ReleaseFolder, ZipName));
str.Write(bytes, 0, bytes.Length);
str.Seek(0, SeekOrigin.Begin);
Logger.WriteLine($"Release zip loaded");
var au = new ReleaseAssetUpload
{
FileName = ZipName,
ContentType = "application/zip",
RawData = str
};
Logger.WriteLine($"Uploading asset");
await Client.Repository.Release.UploadAsset(rls, au);
Logger.WriteLine($"Asset uploaded");
}
/// <summary>
/// Uploads an asset file to a GitHub release. Any existing asset with same name will be replaced.
/// </summary>
/// <param name="repo">Identifies the target repository.</param>
/// <param name="release">The target release.</param>
/// <param name="assetPath">Path to the source asset file.</param>
/// <param name="assetName">Optionally specifies the file name to assign to the asset. This defaults to the file name in <paramref name="assetPath"/>.</param>
/// <param name="contentType">Optionally specifies the asset's <b>Content-Type</b>. This defaults to: <b> application/octet-stream</b></param>
/// <returns>The new <see cref="ReleaseAsset"/>.</returns>
/// <exception cref="NotSupportedException">Thrown when the releas has already been published.</exception>
/// <remarks>
/// <note>
/// The current implementation only works for unpublished releases where <c>Draft=true</c>.
/// </note>
/// </remarks>
public ReleaseAsset UploadAsset(string repo, Release release, string assetPath, string assetName = null, string contentType = "application/octet-stream")
{
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(repo), nameof(repo));
Covenant.Requires <ArgumentNullException>(release != null, nameof(release));
Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(assetPath), nameof(assetPath));
if (!release.Draft)
{
throw new NotSupportedException("Cannot upload asset to already published release.");
}
var repoPath = GitHubRepoPath.Parse(repo);
var client = GitHub.CreateGitHubClient(repo);
using (var assetStream = File.OpenRead(assetPath))
{
if (string.IsNullOrEmpty(assetName))
{
assetName = Path.GetFileName(assetPath);
}
var upload = new ReleaseAssetUpload()
{
FileName = assetName,
ContentType = contentType,
RawData = assetStream
};
return(client.Repository.Release.UploadAsset(release, upload).Result);
}
}
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);
}
/// <summary>
/// Uploads a <see cref="ReleaseAsset"/> for the specified release.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#upload-a-release-asset">API documentation</a> for more information.
/// </remarks>
/// <param name="release">The <see cref="Release"/> to attach the uploaded asset to</param>
/// <param name="data">Description of the asset with its data</param>
/// <param name="cancellationToken">An optional token to monitor for cancellation requests</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
public IObservable <ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data, CancellationToken cancellationToken = default)
{
Ensure.ArgumentNotNull(release, nameof(release));
Ensure.ArgumentNotNull(data, nameof(data));
return(_client.UploadAsset(release, data, cancellationToken).ToObservable());
}
static async Task CreateRelease(GitHubClient github, string owner, string repository, string milestone, string targetCommitish, string asset, string outputFile, bool createFile)
{
var releaseNotesBuilder = new ReleaseNotesBuilder(new DefaultGitHubClient(github, owner, repository), owner, repository, milestone);
var result = await releaseNotesBuilder.BuildReleaseNotes();
if (createFile)
{
CreateReleaseNotesFile(result, outputFile);
}
else
{
var releaseUpdate = new NewRelease(milestone)
{
Draft = true,
Body = result,
Name = milestone,
};
if (!string.IsNullOrEmpty(targetCommitish))
{
releaseUpdate.TargetCommitish = targetCommitish;
}
var release = await github.Repository.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.Repository.Release.UploadAsset(release, upload);
}
}
}
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);
}
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);
}
/// <summary>
/// Uploads a <see cref="ReleaseAsset"/> for the specified release.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#upload-a-release-asset">API documentation</a> for more information.
/// </remarks>
/// <param name="release">The <see cref="Release"/> to attach the uploaded asset to</param>
/// <param name="data">Description of the asset with its data</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
/// <returns>The created <see cref="ReleaseAsset"/>.</returns>
public IObservable <ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data)
{
Ensure.ArgumentNotNull(release, "release");
Ensure.ArgumentNotNull(data, "data");
return(_client.UploadAsset(release, data).ToObservable());
}
public async Task CanUploadAndRetrieveAnAssetWithRepositoryId()
{
var releaseWithNoUpdate = new NewRelease("0.1")
{
Draft = true
};
var release = await _releaseClient.Create(_context.Repository.Id, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload("hello-world.txt", "text/plain", stream, null);
var result = await _releaseClient.UploadAsset(release, newAsset);
Assert.True(result.Id > 0);
var assets = await _releaseClient.GetAllAssets(_context.Repository.Id, release.Id);
Assert.Equal(1, assets.Count);
var asset = assets[0];
Assert.Equal(result.Id, asset.Id);
Assert.NotNull(asset.Url);
Assert.NotNull(asset.BrowserDownloadUrl);
}
private ReleaseAsset UploadAsset(GitHubClient client, Release release, string name, string path, string contentType)
{
using (var stream = new FileStream(path, System.IO.FileMode.Open))
{
var asset = new ReleaseAssetUpload(name, contentType, stream, Timeout);
return(client.Repository.Release.UploadAsset(release, asset).Result);
}
}
internal static async Task CreateRelease()
{
try
{
string version = BuildConfig.GetAppVersionString();
var newRelease = new NewRelease(version);
newRelease.Name = $"New Update {version}";
newRelease.Body = $"Update for version {version}";
newRelease.Draft = false;
newRelease.Prerelease = false;
var gitHub = new GitHubClient(new ProductHeaderValue(BuildConfig.GetGitAppName()));
gitHub.Credentials = new Credentials(BuildConfig.GetGitToken());
bool success = false;
int maxTries = 2;
int current = 0;
Release release = null;
while (!success && current++ < maxTries)
{
release = await gitHub.Repository.Release.Create("clauderoy790", BuildConfig.GetGitAppName(), newRelease);
success = release != null && !string.IsNullOrEmpty(release.UploadUrl);
}
if (!success)
{
throw new Exception($"Failed to create new releaes, tried {current} times.");
}
var files = Directory.GetFiles(BuildConfig.GetGitRepoLocalPath());
foreach (var file in files)
{
if (!BuildConfig.ShouldIncludeFileInReleaseAsset(file))
{
continue;
}
using (var fs = File.OpenRead(file))
{
FileInfo info = new FileInfo(file);
var assetUpload = new ReleaseAssetUpload()
{
FileName = info.Name,
ContentType = MimeMapping.GetMimeMapping(info.Name),
RawData = fs
};
var asset = await gitHub.Repository.Release.UploadAsset(release, assetUpload);
Console.WriteLine($"Uploaded asset {info.Name} to release {version} successfully");
};
}
}
catch (Exception ex)
{
Console.WriteLine($"Failed to create release: {ex.Message}");
}
Console.WriteLine("Release creation done");
}
public async Task <ReleaseInfo> MakeRelease(IGraph dataGraph, string releaseTag, string owner, string repositoryId, string datasetId, string repositoryDirectory, string authenticationToken)
{
var releaseInfo = new ReleaseInfo(releaseTag);
var ntriplesDumpFileName = Path.Combine(repositoryDirectory, releaseTag + ".nt.gz");
ProgressLog.Info("Generating gzipped NTriples data dump");
var writer = new GZippedNTriplesWriter();
writer.Save(dataGraph, ntriplesDumpFileName);
// Make a release
try
{
ProgressLog.Info("Generating a new release of dataset {0}", datasetId);
if (authenticationToken == null)
{
throw new WorkerException("No valid GitHub access token found for your account.");
}
var client = _gitHubClientFactory.CreateClient(authenticationToken);
client.SetRequestTimeout(TimeSpan.FromSeconds(300));
var releaseClient = client.Repository.Release;
var newRelease = new NewRelease(releaseTag)
{
TargetCommitish = "gh-pages"
};
var release = await releaseClient.Create(owner, repositoryId, newRelease);
// Attach data dump file(s) to release
try
{
ProgressLog.Info("Uploading data dump files to GitHub release");
using (var zipFileStream = File.OpenRead(ntriplesDumpFileName))
{
var upload = new ReleaseAssetUpload(Path.GetFileName(ntriplesDumpFileName), "application/gzip",
zipFileStream, null);
var releaseAsset = await releaseClient.UploadAsset(release, upload);
releaseInfo.DownloadLinks.Add(releaseAsset.BrowserDownloadUrl);
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed to attach dump files to GitHub release");
throw new WorkerException(ex, "Failed to attach dump files to GitHub release");
}
}
catch (WorkerException)
{
throw;
}
catch (Exception ex)
{
Log.Error(ex, "Failed to create a new GitHub release");
throw new WorkerException(ex, "Failed to create a new GitHub release");
}
return(releaseInfo);
}
public static async Task PublishRelease(Configure <GitHubReleaseSettings> configure)
{
var settings = configure.Invoke(new GitHubReleaseSettings());
settings.Validate();
var releaseTag = settings.Tag;
var client = GetAuthenticatedClient(settings.Token, settings.Url);
var existingReleases = await client.Repository.Release.GetAll(settings.RepositoryOwner, settings.RepositoryName);
if (existingReleases.Any(r => r.TagName == releaseTag))
{
// Release already present
return;
}
var newRelease = new NewRelease(releaseTag)
{
TargetCommitish = settings.CommitSha,
Name = settings.Name ?? releaseTag,
Body = settings.ReleaseNotes,
Draft = true,
Prerelease = settings.Prerelease ?? false
};
Logger.Info("Creating release draft...");
var releaseCreationResult = await client.Repository.Release.Create(settings.RepositoryOwner, settings.RepositoryName, newRelease);
var createdRelease = await client.Repository.Release.Get(settings.RepositoryOwner, settings.RepositoryName, releaseCreationResult.Id);
if (settings.ArtifactPaths != null)
{
foreach (var artifactPath in settings.ArtifactPaths)
{
using (var artifactStream = File.OpenRead(artifactPath))
{
var fileName = Path.GetFileName(artifactPath);
var assetUpload = new ReleaseAssetUpload
{
FileName = fileName,
ContentType = "application/octet-stream",
RawData = artifactStream,
};
Logger.Info($"Uploading artifact {artifactPath}...");
await client.Repository.Release.UploadAsset(createdRelease, assetUpload);
}
}
}
var updatedRelease = createdRelease.ToUpdate();
updatedRelease.Draft = false;
await client.Repository.Release.Edit(settings.RepositoryOwner, settings.RepositoryName, createdRelease.Id, updatedRelease);
Logger.Info($"Release {settings.Name ?? releaseTag} was successfully created");
}
protected override void ProcessRecord()
{
try
{
var gitUri = GitHubClient.GitHubApiUrl;
if (GitSourceOption == "external")
{
gitUri = new Uri(GitSourceUrl);
}
var client = new GitHubClient(new ProductHeaderValue(ApplicationName), gitUri);
var tokenAuth = new Credentials(Token);
client.Credentials = tokenAuth;
var newRelease = new NewRelease(TagName)
{
Name = ReleaseName,
Body = ReleaseBody,
Draft = Draft,
Prerelease = PreRelease,
};
var release = client.Repository.Release.Create(Owner, Repo, newRelease).Result;
WriteVerbose("Created release with id: " + release.Id + " at " + release.Url);
if (Assets != null && Assets.Any())
{
WriteVerbose("Uploading " + Assets.Count() + " assets");
foreach (var asset in Assets)
{
WriteVerbose("Uploading " + asset);
using (var archiveContents = File.OpenRead(asset))
{
var fileName = Path.GetFileName(asset);
var assetUpload = new ReleaseAssetUpload()
{
FileName = fileName,
ContentType = "application/zip",
RawData = archiveContents
};
var uploadedAsset = client.Repository.Release.UploadAsset(release, assetUpload).Result;
WriteVerbose("Uploaded " + uploadedAsset.Name);
}
}
}
else
{
WriteVerbose("No assets specified");
}
}
catch (Exception e)
{
WriteVerbose("Error when publishing release: " + e);
throw;
}
}
public async Task EnsuresArgumentsNotNull()
{
var releasesClient = new ReleasesClient(Substitute.For <IApiConnection>());
var release = new Release("https://uploads.github.com/anything");
var uploadData = new ReleaseAssetUpload("good", "good/good", Stream.Null, null);
await Assert.ThrowsAsync <ArgumentNullException>(() => releasesClient.UploadAsset(null, uploadData));
await Assert.ThrowsAsync <ArgumentNullException>(() => releasesClient.UploadAsset(release, null));
}
public void EnsuresArgumentsNotNull()
{
var releasesClient = new ObservableReleasesClient(Substitute.For <IGitHubClient>());
var release = new Release("https://uploads.github.com/anything");
var uploadData = new ReleaseAssetUpload("good", "good/good", Stream.Null, null);
Assert.Throws <ArgumentNullException>(() => releasesClient.UploadAsset(null, uploadData));
Assert.Throws <ArgumentNullException>(() => releasesClient.UploadAsset(release, null));
}
public async Task Create(string name, string description, string assetDir)
{
int createdReleaseId = -1;
var client = new GitHubClient(new ProductHeaderValue("kinv-release-app"));
try
{
var tokenAuth = new Credentials(ghToken); // NOTE: not real token
client.Credentials = tokenAuth;
var newRelease = new NewRelease(name);
newRelease.Name = "v" + name;
newRelease.Body = description;
newRelease.Draft = false;
newRelease.Prerelease = false;
var result = await client.Repository.Release.Create(ghUser, ghRepo, newRelease);
Console.WriteLine("Created release id {0}", result.Id);
createdReleaseId = result.Id;
var release = await client.Repository.Release.Get(ghUser, ghRepo, result.Id);
var files = Directory.GetFiles(assetDir);
foreach (var file in files)
{
using (var contents = File.OpenRead(file))
{
var assetUpload = new ReleaseAssetUpload()
{
FileName = Path.GetFileName(file),
ContentType = file.EndsWith(".exe") ? "application/binary" : "application/zip",
RawData = contents
};
var asset = await client.Repository.Release.UploadAsset(release, assetUpload);
}
}
}
catch (Exception exc)
{
// if created and failed, delete it
Console.Error.Write("Failed to create release: " + exc.Message);
if (createdReleaseId != -1)
{
try
{
await client.Repository.Release.Delete(ghUser, ghRepo, createdReleaseId);
}
catch (Exception exc2)
{
Console.Error.Write("Failed to delete release: " + exc2.Message);
}
}
}
}
static Task UploadFileToGithub(Release githubRelease, string filePath, string filePublishName, string contentType)
{
var buildZipAssetWindows = new ReleaseAssetUpload()
{
FileName = filePublishName,
ContentType = contentType,
RawData = File.OpenRead(filePath)
};
return(github.Release.UploadAsset(githubRelease, buildZipAssetWindows));
}
public void RequestsTheCorrectUrl()
{
var gitHubClient = Substitute.For <IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var release = new Release("https://uploads.test.dev/does/not/matter/releases/1/assets{?name}");
var rawData = Substitute.For <Stream>();
var upload = new ReleaseAssetUpload("example.zip", "application/zip", rawData, null);
releasesClient.UploadAsset(release, upload);
gitHubClient.Repository.Release.Received(1).UploadAsset(release, upload);
}
private ReleaseAssetUpload BuildAssetUpload(ITaskItem item)
{
var data = new ReleaseAssetUpload();
data.ContentType = item.GetMetadata("ContentType");
if (data.ContentType == null)
{
data.ContentType = "application/octet-stream";
}
data.FileName = Path.GetFileName(item.ItemSpec);
data.RawData = File.OpenRead(item.ItemSpec);
return(data);
}
private async Task UploadRelease(GitHubClient client, Release release, string version)
{
using (var archiveContents = File.OpenRead(@"output\clock-setup.exe"))
{
var assetUpload = new ReleaseAssetUpload()
{
FileName = $"clock-setup-{version}.exe",
ContentType = "application/vnd.microsoft.portable-executable",
RawData = archiveContents
};
Logger.Normal($"Uploading release");
var asset = await client.Repository.Release.UploadAsset(release, assetUpload);
}
}
public void EnsuresArgumentsNotNull()
{
var releasesClient = new ObservableReleasesClient(Substitute.For <IGitHubClient>());
var release = new Release {
UploadUrl = "https://uploads.github.com/anything"
};
var uploadData = new ReleaseAssetUpload {
FileName = "good", ContentType = "good/good", RawData = Stream.Null
};
Assert.Throws <ArgumentNullException>(() => releasesClient.UploadAsset(null, uploadData));
Assert.Throws <ArgumentNullException>(() => releasesClient.UploadAsset(release, null));
}
private static async Task ReleaseAsync()
{
var sha = Environment.GetEnvironmentVariable("sha");
var token = Environment.GetEnvironmentVariable("token");
var identity = Environment.GetEnvironmentVariable("repo")?.Split("/");
if (!string.IsNullOrEmpty(token))
{
var owner = identity?[0];
var repoName = identity?[1];
var client = new GitHubClient(new ProductHeaderValue(owner))
{
Credentials = new Credentials(token)
};
var comment = string.Join("\n",
(await client.Repository.Comment.GetAllForCommit(owner, repoName, sha)).Select(c => c.Body));
var tagName = $"汉化资源包-Snapshot-{DateTime.UtcNow:yyyyMMddhhmmss}";
var tag = new NewTag
{
Object = sha,
Message = comment,
Tag = tagName,
Type = TaggedType.Commit,
Tagger = new Committer("CFPABot", "*****@*****.**", DateTimeOffset.UtcNow)
};
var tagResult = await client.Git.Tag.Create(owner, repoName, tag);
Console.WriteLine($"Created a tag for {tagResult.Tag} at {tagResult.Sha}");
var newRelease = new NewRelease(tagName)
{
Name = tagName,
Body = tag.Message,
Draft = false,
Prerelease = false
};
var releaseResult = await client.Repository.Release.Create(owner, repoName, newRelease);
Console.WriteLine($"Created release id {releaseResult.Id}");
await using var rawData = File.OpenRead(@"./Minecraft-Mod-Language-Modpack.zip");
var assetUpload = new ReleaseAssetUpload
{
FileName = "Minecraft-Mod-Language-Modpack.zip",
ContentType = "application/zip",
RawData = rawData
};
var release = await client.Repository.Release.Get(owner, repoName, releaseResult.Id);
await client.Repository.Release.UploadAsset(release, assetUpload);
}
}
public async Task EnsuresArgumentsNotNull()
{
var releasesClient = new ReleasesClient(Substitute.For <IApiConnection>());
var release = new Release {
UploadUrl = "https://uploads.github.com/anything"
};
var uploadData = new ReleaseAssetUpload {
FileName = "good", ContentType = "good/good", RawData = Stream.Null
};
await AssertEx.Throws <ArgumentNullException>(async() => await releasesClient.UploadAsset(null, uploadData));
await AssertEx.Throws <ArgumentNullException>(async() => await releasesClient.UploadAsset(release, null));
}
public async Task OverrideDefaultTimeout()
{
var newTimeout = TimeSpan.FromSeconds(100);
var apiConnection = Substitute.For <IApiConnection>();
var fixture = new ReleasesClient(apiConnection);
var release = new Release("https://uploads.github.com/anything");
var uploadData = new ReleaseAssetUpload("good", "good/good", Stream.Null, newTimeout);
await fixture.UploadAsset(release, uploadData);
apiConnection.Received().Post <ReleaseAsset>(Arg.Any <Uri>(), uploadData.RawData, Arg.Any <string>(), uploadData.ContentType, newTimeout);
}
public static async Task PublishRelease(GitHubReleaseSettings settings)
{
var releaseTag = settings.Tag;
var client = GetAuthenticatedClient(settings.Token);
var existingReleases = await client.Repository.Release.GetAll(settings.RepositoryOwner, settings.RepositoryName);
if (existingReleases.Any(r => r.TagName == releaseTag))
{
// Release already present
return;
}
var newRelease = new NewRelease(releaseTag)
{
TargetCommitish = settings.CommitSha,
Name = releaseTag,
Body = settings.ReleaseNotes,
Draft = true,
Prerelease = settings.Prerelease ?? false
};
var releaseCreationResult = await client.Repository.Release.Create(settings.RepositoryOwner, settings.RepositoryName, newRelease);
var createdRelease = await client.Repository.Release.Get(settings.RepositoryOwner, settings.RepositoryName, releaseCreationResult.Id);
if (settings.ArtifactPaths != null)
{
foreach (var artifactPath in settings.ArtifactPaths)
{
using (var artifactStream = File.OpenRead(artifactPath))
{
var fileName = Path.GetFileName(artifactPath);
var assetUpload = new ReleaseAssetUpload
{
FileName = fileName,
ContentType = "application/octet-stream",
RawData = artifactStream,
};
await client.Repository.Release.UploadAsset(createdRelease, assetUpload);
}
}
}
var updatedRelease = createdRelease.ToUpdate();
updatedRelease.Draft = false;
await client.Repository.Release.Edit(settings.RepositoryOwner, settings.RepositoryName, createdRelease.Id, updatedRelease);
}
static async Task Release(string username, string token, string repo, string projectName, string buildNumber, bool promote, string target, string buildDir)
{
GitHubClient client = new GitHubClient(new ProductHeaderValue("GitHubReleaser"));
var basicAuth = new Credentials(token);
client.Credentials = basicAuth;
var releases = client.Repository.Release.GetAll(username, repo);
try
{
var latestRelease = await client.Repository.Release.GetLatest(username, repo);
if (string.IsNullOrWhiteSpace(buildNumber))
{
buildNumber = (int.Parse(latestRelease.TagName.Split('-')[1]) + 1).ToString();
}
}
catch (Exception)
{
buildNumber = "1";
}
Zip(projectName, buildNumber, target, buildDir);
var newRelease = new NewRelease("Build-" + buildNumber);
newRelease.Name = "Build " + buildNumber + " @ " + DateTime.UtcNow.ToString("MM/dd/yyyy HH:mm:ss UTC");
newRelease.Body = promote ? "This was automatically uploaded by [GitHubReleaser](https://github.com/BadCodr/GitHubReleaser) @BadCodr" : "";
newRelease.Draft = false;
newRelease.Prerelease = false;
var result = await client.Repository.Release.Create(username, repo, newRelease);
var archiveContents = File.OpenRead(Path.GetTempPath() + projectName + buildNumber + ".zip"); // TODO: better sample
var assetUpload = new ReleaseAssetUpload()
{
FileName = projectName + buildNumber + ".zip",
ContentType = "application/zip",
RawData = archiveContents
};
var asset = await client.Repository.Release.UploadAsset(result, assetUpload);
Clean(projectName, buildNumber);
Console.WriteLine("Created release id {0}", releases.Id);
}
public void UploadsToCorrectUrl()
{
var client = Substitute.For<IApiConnection>();
var releasesClient = new ReleasesClient(client);
var release = new Release { UploadUrl = "https://uploads.test.dev/does/not/matter/releases/1/assets{?name}" };
var rawData = Substitute.For<Stream>();
var upload = new ReleaseAssetUpload { FileName = "example.zip", ContentType = "application/zip", RawData = rawData };
releasesClient.UploadAsset(release, upload);
client.Received().Post<ReleaseAsset>(
Arg.Is<Uri>(u => u.ToString() == "https://uploads.test.dev/does/not/matter/releases/1/assets?name=example.zip"),
rawData,
"application/vnd.github.v3",
Arg.Is<string>(contentType => contentType == "application/zip"));
}
public async Task UploadsToCorrectUrl()
{
var client = Substitute.For <IApiConnection>();
var releasesClient = new ReleasesClient(client);
var release = new Release("https://uploads.test.dev/does/not/matter/releases/1/assets{?name}");
var rawData = Substitute.For <Stream>();
var upload = new ReleaseAssetUpload("example.zip", "application/zip", rawData, null);
await releasesClient.UploadAsset(release, upload);
client.Received().Post <ReleaseAsset>(
Arg.Is <Uri>(u => u.ToString() == "https://uploads.test.dev/does/not/matter/releases/1/assets?name=example.zip"),
rawData,
"application/vnd.github.v3",
Arg.Is <string>(contentType => contentType == "application/zip"));
}
public void CallsIntoClient()
{
var gitHubClient = Substitute.For <IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var release = new Release {
UploadUrl = "https://uploads.test.dev/does/not/matter/releases/1/assets{?name}"
};
var rawData = Substitute.For <Stream>();
var upload = new ReleaseAssetUpload {
FileName = "example.zip", ContentType = "application/zip", RawData = rawData
};
releasesClient.UploadAsset(release, upload);
gitHubClient.Release.Received(1).UploadAsset(release, upload);
}
public void EnsuresArgumentsNotNull()
{
var releasesClient = new ObservableReleasesClient(Substitute.For<IGitHubClient>());
var release = new Release("https://uploads.github.com/anything");
var uploadData = new ReleaseAssetUpload("good", "good/good", Stream.Null, null);
Assert.Throws<ArgumentNullException>(() => releasesClient.UploadAsset(null, uploadData));
Assert.Throws<ArgumentNullException>(() => releasesClient.UploadAsset(release, null));
}
public void CallsIntoClient()
{
var gitHubClient = Substitute.For<IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var release = new Release("https://uploads.test.dev/does/not/matter/releases/1/assets{?name}");
var rawData = Substitute.For<Stream>();
var upload = new ReleaseAssetUpload("example.zip", "application/zip", rawData, null);
releasesClient.UploadAsset(release, upload);
gitHubClient.Repository.Release.Received(1).UploadAsset(release, upload);
}
public IObservable<ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data)
{
return _client.UploadAsset(release, data).ToObservable();
}
public async Task OverrideDefaultTimeout()
{
var newTimeout = TimeSpan.FromSeconds(100);
var apiConnection = Substitute.For<IApiConnection>();
var fixture = new ReleasesClient(apiConnection);
var release = new Release("https://uploads.github.com/anything");
var uploadData = new ReleaseAssetUpload("good", "good/good", Stream.Null, newTimeout);
await fixture.UploadAsset(release, uploadData);
apiConnection.Received().Post<ReleaseAsset>(Arg.Any<Uri>(), uploadData.RawData, Arg.Any<string>(), uploadData.ContentType, newTimeout);
}
public async Task EnsuresNonNullArguments()
{
var releasesClient = new ReleasesClient(Substitute.For<IApiConnection>());
var release = new Release("https://uploads.github.com/anything");
var uploadData = new ReleaseAssetUpload("good", "good/good", Stream.Null, null);
await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.UploadAsset(null, uploadData));
await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.UploadAsset(release, null));
}
public async Task EnsuresArgumentsNotNull()
{
var releasesClient = new ReleasesClient(Substitute.For<IApiConnection>());
var release = new Release { UploadUrl = "https://uploads.github.com/anything" };
var uploadData = new ReleaseAssetUpload { FileName = "good", ContentType = "good/good", RawData = Stream.Null };
await AssertEx.Throws<ArgumentNullException>(async () => await releasesClient.UploadAsset(null, uploadData));
await AssertEx.Throws<ArgumentNullException>(async () => await releasesClient.UploadAsset(release, null));
}
/// <summary>
/// Uploads a <see cref="ReleaseAsset"/> for the specified release.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#upload-a-release-asset">API documentation</a> for more information.
/// </remarks>
/// <param name="release">The <see cref="Release"/> to attach the uploaded asset to</param>
/// <param name="data">Description of the asset with its data</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
public IObservable<ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data)
{
Ensure.ArgumentNotNull(release, "release");
Ensure.ArgumentNotNull(data, "data");
return _client.UploadAsset(release, data).ToObservable();
}
public void CallsIntoClient()
{
var gitHubClient = Substitute.For<IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var release = new Release { UploadUrl = "https://uploads.test.dev/does/not/matter/releases/1/assets{?name}" };
var rawData = Substitute.For<Stream>();
var upload = new ReleaseAssetUpload { FileName = "example.zip", ContentType = "application/zip", RawData = rawData };
releasesClient.UploadAsset(release, upload);
gitHubClient.Release.Received(1).UploadAsset(release, upload);
}
public void EnsuresArgumentsNotNull()
{
var releasesClient = new ObservableReleasesClient(Substitute.For<IGitHubClient>());
var release = new Release { UploadUrl = "https://uploads.github.com/anything" };
var uploadData = new ReleaseAssetUpload { FileName = "good", ContentType = "good/good", RawData = Stream.Null };
Assert.Throws<ArgumentNullException>(() => releasesClient.UploadAsset(null, uploadData));
Assert.Throws<ArgumentNullException>(() => releasesClient.UploadAsset(release, null));
}
public void UploadsToCorrectUrl()
{
var gitHubClient = Substitute.For<IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var release = new Release { UploadUrl = "https://uploads.test.dev/does/not/matter/releases/1/assets{?name}" };
var rawData = Substitute.For<Stream>();
var upload = new ReleaseAssetUpload { FileName = "example.zip", ContentType = "application/zip", RawData = rawData };
releasesClient.UploadAsset(release, upload);
gitHubClient.Connection.PostAsync<ReleaseAsset>(
new Uri("https://uploads.test.dev/does/not/matter/releases/1/assets?name=example.zip", UriKind.Absolute),
rawData,
"application/vnd.github.v3",
Arg.Is<string>(contentType => contentType == "application/zip"));
}
