protected override void ProcessRecord()
{
base.ProcessRecord();
if (!File.Exists(Filename))
{
throw new FileNotFoundException(Filename);
}
Release release = GitHub.Release.Get(Owner, Repository, ReleaseId).Result;
if (release == null)
{
WriteError(new KeyNotFoundException(ReleaseId.ToString()), ErrorCategory.ObjectNotFound);
return;
}
var fileStream = File.OpenRead(Filename);
var releaseAssetUpload = new ReleaseAssetUpload
{
ContentType = ContentType,
FileName = Path.GetFileName(Filename),
RawData = fileStream
};
WriteObject(GitHub.Release.UploadAsset(release, releaseAssetUpload).Result);
}
async Task PublishRelease(string owner, string repo, string token, string tag, string description, string artifactPath, bool prerelease)
{
var tokenAuth = new Octokit.Credentials(token);
var githubClient = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("vc-build"))
{
Credentials = tokenAuth
};
var newRelease = new Octokit.NewRelease(tag)
{
Name = tag,
Prerelease = prerelease,
Draft = false,
Body = description
};
var release = await githubClient.Repository.Release.Create(owner, repo, newRelease);
using (var artifactStream = File.OpenRead(artifactPath))
{
var assetUpload = new Octokit.ReleaseAssetUpload()
{
FileName = Path.GetFileName(artifactPath),
ContentType = "application/zip",
RawData = artifactStream
};
var asset = await githubClient.Repository.Release.UploadAsset(release, assetUpload);
}
}
public Task <ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data, CancellationToken cancellationToken = default)
{
Ensure.ArgumentNotNull(release, nameof(release));
Ensure.ArgumentNotNull(data, nameof(data));
var endpoint = release.UploadUrl.ExpandUriTemplate(new { name = data.FileName });
if (data.Timeout.HasValue)
{
return(ApiConnection.Post <ReleaseAsset>(
endpoint,
data.RawData,
AcceptHeaders.StableVersion,
data.ContentType,
data.Timeout.GetValueOrDefault(),
cancellationToken));
}
return(ApiConnection.Post <ReleaseAsset>(
endpoint,
data.RawData,
AcceptHeaders.StableVersion,
data.ContentType,
cancellationToken));
}
/// <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 Task<ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data)
{
Ensure.ArgumentNotNull(release, "release");
Ensure.ArgumentNotNull(data, "data");
var endpoint = release.UploadUrl.ExpandUriTemplate(new {name = data.FileName});
return ApiConnection.Post<ReleaseAsset>(
endpoint,
data.RawData,
"application/vnd.github.manifold-preview",
data.ContentType);
}
/// <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 Task <ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data)
{
Ensure.ArgumentNotNull(release, "release");
Ensure.ArgumentNotNull(data, "data");
var endpoint = release.UploadUrl.ExpandUriTemplate(new { name = data.FileName });
return(ApiConnection.Post <ReleaseAsset>(
endpoint,
data.RawData,
"application/vnd.github.v3",
data.ContentType));
}
public async Task CanDownloadBinaryAsset()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.zip");
var newAsset = new ReleaseAssetUpload("hello-world.zip"
, "application/octet-stream"
, stream
, null);
var result = await _releaseClient.UploadAsset(release, newAsset);
Assert.True(result.Id > 0);
var asset = await _releaseClient.GetAsset(_context.RepositoryOwner, _context.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");
var textContent = string.Empty;
using (var zipstream = new MemoryStream((byte[])response.Body))
using (var archive = new ZipArchive(zipstream))
{
var enttry = archive.Entries[0];
var data = new byte[enttry.Length];
await enttry.Open().ReadAsync(data, 0, data.Length);
textContent = Encoding.ASCII.GetString(data);
}
Assert.Contains("This is a plain text file.", textContent);
}
public async Task CanDownloadAnAsset()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, 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 asset = await _releaseClient.GetAsset(_context.RepositoryOwner, _context.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.Contains("This is a plain text file.", Encoding.ASCII.GetString((byte[])response.Body));
}
public async Task CanUploadAndRetrieveAnAsset()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, 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.RepositoryOwner, _context.RepositoryName, 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 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 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);
}
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);
}
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)
};
await github.Release.UploadAsset(release, upload);
}
}
}
public static void Publish(string projectInfoFilename, string releaseBasePath, string releaseVersion, string userFriendlyDate, string isoDate, string user, string pw)
{
if (projectInfoFilename == null) {
throw new ArgumentNullException("projectInfoFilename");
}
if (releaseVersion == null) {
throw new ArgumentNullException("releaseVersion");
}
if (userFriendlyDate == null) {
throw new ArgumentNullException("userFriendlyDate");
}
if (isoDate == null) {
throw new ArgumentNullException("isoDate");
}
if (user == null) {
throw new ArgumentNullException("user");
}
if (pw == null) {
throw new ArgumentNullException("pw");
}
var nsMap = new XmlNamespaceManager(new NameTable());
nsMap.AddNamespace("local", "http://local/");
var doc = new XmlDocument();
doc.Load(projectInfoFilename);
string projectName;
var node = doc.DocumentElement.SelectSingleNode("/local:project/local:id[@service = 'Github']/text()", nsMap);
if (node != null) {
projectName = node.Value;
} else {
projectName = doc.DocumentElement.SelectSingleNode("/local:project/local:id/text()", nsMap).Value;
}
var version = versionStructure.Match(releaseVersion);
if (!version.Success) {
throw new ArgumentException(string.Format(System.Globalization.CultureInfo.InvariantCulture,
"The release version \"{0}\" does not match the format requirements.",
releaseVersion));
}
bool isPrerelease = (version.Groups.Count > 2) && !string.IsNullOrWhiteSpace(version.Groups[2].Value);
string releaseName = CreateReleaseName(version, isPrerelease);
//string status = DetermineStatus(version, isPrerelease);
string releaseDesc = CompileReleaseNotes(doc, nsMap);
var github = new GitHubClient(new ProductHeaderValue(typeof(Worker).Assembly.FullName));
github.Credentials = new Credentials(user, pw);
var releaseClient = github.Release;
var releaseData = new NewRelease(releaseName);
releaseData.Body = releaseDesc;
releaseData.Prerelease = isPrerelease;
releaseData.Name = releaseName;
var releaseTask = github.Release.Create(user, projectName, releaseData);
releaseTask.RunSynchronously();
var release = releaseTask.Result;
var files = ExtractReleaseFiles(doc, nsMap, releaseBasePath, releaseVersion, userFriendlyDate).ToArray();
foreach (ReleaseFileInfo f in files) {
var asset = new ReleaseAssetUpload(f.DestName, f.MimeType, f.Data, null);
var uploadTask = github.Release.UploadAsset(release, asset);
uploadTask.RunSynchronously();
}
}
private static async Task AttachToRelease(GitHubClient github, string owner, string repository, string milestone, string asset)
{
if (!File.Exists(asset))
return;
var releases = await github.Release.GetAll(owner, repository);
var release = releases.FirstOrDefault(r => r.Name == milestone);
if (release == null)
return;
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 CanUploadAndRetrieveAnAsset()
{
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 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);
}
public async Task CanEditAnAssetLabelWithRepositoryId()
{
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);
var asset = await _releaseClient.GetAsset(_context.Repository.Id, result.Id);
var updateAsset = asset.ToUpdate();
updateAsset.Label = "some other thing";
var updatedAsset = await _releaseClient.EditAsset(_context.Repository.Id, 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 Task<ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data)
{
Ensure.ArgumentNotNull(release, "release");
Ensure.ArgumentNotNull(data, "data");
var endpoint = release.UploadUrl.ExpandUriTemplate(new { name = data.FileName });
if (data.Timeout.HasValue)
{
return ApiConnection.Post<ReleaseAsset>(
endpoint,
data.RawData,
"application/vnd.github.v3",
data.ContentType,
data.Timeout.GetValueOrDefault());
}
return ApiConnection.Post<ReleaseAsset>(
endpoint,
data.RawData,
"application/vnd.github.v3",
data.ContentType);
}
public async Task CanDeleteAssetWithRepositoryId()
{
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);
var asset = await _releaseClient.GetAsset(_context.Repository.Id, result.Id);
Assert.NotNull(asset);
Assert.ThrowsAsync<NotFoundException>(async () => await _releaseClient.DeleteAsset(_context.Repository.Id, result.Id));
}
static async Task UploadRelease()
{
// get last master commit to tag
/*var masterBranch = await github.Repository.GetBranch(repoOwner, repoName, "master");
var lastCommit = masterBranch.Commit.Sha;
// create tag
var tagName = "v" + localVersion.ToString();
var tag = new NewTag
{
Message = "Tagging a new release of Jackett",
Tag = tagName,
Object = lastCommit,
Type = TaggedType.Commit,
Tagger = new SignatureResponse("DistributionBot", "*****@*****.**", DateTime.UtcNow)
};
var tagResult = await github.GitDatabase.Tag.Create(repoOwner, repoName, tag);*/
// create release entry
var newRelease = new NewRelease("v" + localVersion.ToString());
newRelease.Name = "Beta Release";
newRelease.Body = "";
newRelease.Draft = true;
newRelease.Prerelease = false;
var releaseResult = await github.Release.Create(repoOwner, repoName, newRelease);
var buildZipAsset = new ReleaseAssetUpload()
{
FileName = string.Format("Jackett.v{0}.zip", localVersion),
ContentType = "application/zip",
RawData = File.OpenRead(buildZipFile)
};
var buildZipAssetResult = await github.Release.UploadAsset(releaseResult, buildZipAsset);
var installFileAsset = new ReleaseAssetUpload()
{
FileName = string.Format("Jackett.v{0}.Windows.Installer.exe", localVersion),
ContentType = "application/octet-stream",
RawData = File.OpenRead(installFile)
};
var installFileAssetResult = await github.Release.UploadAsset(releaseResult, installFileAsset);
}
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;
}